# Abo-Integration mit Checkout erstellen Erstellen und verwalten Sie Abos mit Akzeptanz wiederkehrender Zahlungen mit Checkout. # Vollständig gehostete Seite > This is a Vollständig gehostete Seite for when payment-ui is stripe-hosted. View the full page at https://docs.stripe.com/payments/checkout/build-subscriptions?payment-ui=stripe-hosted. # Vollständige gehostete Seite > This is a Vollständige gehostete Seite for when platform is web and ui is stripe-hosted. View the full page at https://docs.stripe.com/payments/checkout/build-subscriptions?platform=web&ui=stripe-hosted. #### Integrationsaufwand Complexity: 2/5 #### Anpassung der Nutzeroberfläche Eingeschränkte Anpassung - 20 voreingestellte Schriftarten - 3 voreingestellte Rahmenradien - Nutzerdefinierte Hintergrund- und Rahmenfarbe - Individuelles Logo #### Integrationstyp Verwenden Sie vorgefertigte gehostete Seiten, um Zahlungen einzuziehen und *Abos* zu verwalten. [Ausprobieren](https://checkout.stripe.dev/) ## Sie werden Folgendes entwickeln In diesem Leitfaden wird erläutert, wie Sie mit [Stripe Checkout](https://docs.stripe.com/payments/checkout.md) monatliche Festpreis-Abos verkaufen. Dieser Leitfaden bietet Informationen zu den folgenden Vorgehensweisen: - Modellieren Sie Ihr Unternehmen, indem Sie einen Produktkatalog erstellen. - Fügen Sie eine Checkout-Sitzung zu Ihrer Seite hinzu, einschließlich einer Schaltfläche sowie Erfolgs- und Abbruchseiten. - Überwachen Sie Abo-Ereignisse und stellen Sie den Zugang zu Ihrer Dienstleistung bereit. - Richten Sie das [Kundenportal](https://docs.stripe.com/customer-management.md) ein. - Fügen Sie eine Kundenportal-Sitzung zu Ihrer Seite hinzu, einschließlich einer Schaltfläche und einer Umleitung. - Lassen Sie Ihre Kund/innen über das Portal ihre eigenen Abos verwalten. - Erfahren Sie, wie Sie im [flexiblen Abrechnungsmodus](https://docs.stripe.com/billing/subscriptions/billing-mode.md) auf ein verbessertes Abrechnungsverhalten und zusätzliche Funktionen zugreifen können. Wenn Sie zur Codierung einer Integration nicht bereit sind, können Sie einfache Abos [manuell im Dashboard](https://docs.stripe.com/no-code/subscriptions.md) einrichten oder [Payment Links](https://docs.stripe.com/payment-links.md) nutzen, um Abos einzurichten, ohne Code schreiben zu müssen. Erfahren Sie mehr über das [Entwerfen einer Integration](https://docs.stripe.com/billing/subscriptions/design-an-integration.md), um zu verstehen, welche Entscheidungen Sie für eine vollständige Integration treffen müssen und welche Ressourcen Sie benötigen. Nachdem Sie die Integration abgeschlossen haben, können Sie sie auf Folgendes erweitern: - [Steuern](https://docs.stripe.com/payments/checkout/taxes.md) anzeigen - [Rabatte](https://docs.stripe.com/billing/subscriptions/coupons.md#using-coupons-in-checkout) anwenden - Kund/innen einen [kostenlosen Testzeitraum](https://docs.stripe.com/billing/subscriptions/trials.md) anbieten - [Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/integration-options.md) hinzufügen - [Gehostete Rechnungsseite](https://docs.stripe.com/invoicing/hosted-invoice-page.md) integrieren - Checkout im [Einrichtungsmodus](https://docs.stripe.com/payments/save-and-reuse.md) verwenden - [Nutzungsbasierte Abrechnung](https://docs.stripe.com/products-prices/pricing-models.md#usage-based-pricing), [Preisstufen](https://docs.stripe.com/products-prices/pricing-models.md#tiered-pricing) und [nutzungsbasierte Preise](https://docs.stripe.com/products-prices/pricing-models.md#usage-based-pricing) einrichten - [Anteilmäßige Verrechnung](https://docs.stripe.com/billing/subscriptions/prorations.md) verwalten - Ermöglichen Sie es Kund/innen, [mehrere Produkte zu abonnieren](https://docs.stripe.com/billing/subscriptions/quantities.md#multiple-product-sub) - [Berechtigungen](https://docs.stripe.com/billing/entitlements.md) integrieren, um den Zugriff auf die Funktionen Ihres Produkts zu verwalten ## Stripe einrichten 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 optional die Stripe CLI. Die CLI bietet [Webhook](https://docs.stripe.com/webhooks.md#test-webhook)-Tests und kann zum Erstellen Ihrer Produkte und Preise ausgeführt werden. Weitere Installationsoptionen finden Sie unter [Mit der Stripe-CLI loslegen](https://docs.stripe.com/stripe-cli.md). ## Preismodell erstellen [Dashboard oder 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 USD. Der Preis für das Premiumprodukt beträgt 15 USD. 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 USD - Basic-Produkt: Basic-Dienstleistung mit minimalem Funktionsumfang - Preis: Pauschalpreis | 5 USD 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 USD. 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": "usd", "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 } ``` Wenn Sie mehrere Rechnungsstellungszeiträume anbieten, verwenden Sie Checkout, um Kundinnen und Kunden längere Rechnungsstellungszeiträume als [Upsell](https://docs.stripe.com/payments/checkout/upsells.md) anzubieten und mehr Umsatz im Voraus zu erzielen. Weitere Preismodelle finden Sie unter [Abrechnungsbeispiele](https://docs.stripe.com/products-prices/pricing-models.md). ## Checkout-Sitzung erstellen [Client und Server] Fügen Sie Ihrer Website eine Schaltfläche zum Bezahlen hinzu, die einen serverseitigen Endpoint aufruft, um eine Checkout-Sitzung zu erstellen. ```html Checkout
``` Definieren Sie im Backend Ihres Anmeldeformulars einen Endpoint, der [die Sitzung erstellt](https://docs.stripe.com/api/checkout/sessions/create.md), die von Ihrem Frontend aufgerufen werden kann. Sie brauchen dazu folgende Werte: - Die Preis-ID des Abonnements, das die Kundin/der Kundin abschließt (Ihr Frontend übergibt diesen Wert) - Ihre `success_url`, eine Seite auf Ihrer Website, an die Kund/innen nach Abschluss der Zahlung weitergeleitet werden Sie können optional Folgendes tun: - Konfigurieren Sie in diesem Aufruf einen [Abrechnungszyklusanker](https://docs.stripe.com/billing/subscriptions/billing-cycle.md) für Ihr Abo. - Verwenden Sie einen [benutzerdefinierten Text](https://docs.stripe.com/payments/checkout/custom-components.md?platform=web&payment-ui=stripe-hosted#customize-text), um Ihre Abo- und Kündigungskonditionen sowie einen Link anzugeben, über den Ihre Kundinnen und Kunden ihr Abo aktualisieren oder kündigen können. Wir empfehlen Ihnen, [E-Mail-Erinnerungen und Benachrichtigungen](https://docs.stripe.com/invoicing/send-email.md#email-configuration) für Ihre Abonnentinnen und Abonnenten zu konfigurieren. Wenn Sie in [Schritt 2](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md#create-pricing-model) einen einmaligen Preis erstellt haben, übergeben Sie auch diese Preis-ID. Leiten Sie Ihre Kund/innen nach dem Erstellen einer Checkout-Sitzung an die in der Antwort zurückgegebene [URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) weiter. Sie können beim Erstellen einer Checkout-Sitzung ein genaueres und besser vorhersehbares Aboverhalten aktivieren, indem Sie den Typ des [Abrechnungsmodus](https://docs.stripe.com/billing/subscriptions/billing-mode.md) auf `flexibel` einstellen. Sie müssen die Stripe API Version [2025-06-30.basil](https://docs.stripe.com/upgrades.md) oder höher verwenden. > Sie können [lookup_keys](https://docs.stripe.com/products-prices/manage-prices.md#lookup-keys) anstelle von Preis-IDs verwenden, um Preise abzurufen. Ein Beispiel finden Sie in der [Beispielanwendung](https://github.com/stripe-samples/subscription-use-cases/tree/main/fixed-price-subscriptions). #### 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('<>') # The price ID passed from the front end. # price_id = params['priceId'] price_id = '{{PRICE_ID}}' session = client.v1.checkout.sessions.create({ success_url: 'https://example.com/success.html?session_id={CHECKOUT_SESSION_ID}', mode: 'subscription', line_items: [{ # For usage-based billing, don't pass quantity quantity: 1, price: price_id }], subscription_data: { billing_mode: { type: 'flexible' } } }) # Redirect to the URL returned on the session # redirect session.url, 303 ``` In diesem Beispiel wird die `success_url` durch Anhängen der Sitzungs-ID angepasst. Erfahren Sie mehr über das [Anpassen Ihrer Erfolgsseite](https://docs.stripe.com/payments/checkout/custom-success-page.md). Aktivieren Sie in Ihrem [Dashboard](https://dashboard.stripe.com/settings/payment_methods) die Zahlungsmethoden, die Sie von Ihren Kund/innen akzeptieren möchten. Checkout unterstützt [mehrere Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/payment-method-support.md#product-support). ## Abos bereitstellen und überwachen [Server] Nach erfolgreicher Registrierung eines Abonnements wird der Kunde zur `success_url` Ihrer Website zurückgeleitet, wodurch ein `checkout.session.completed` *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) ausgelöst wird. Wenn Sie ein `checkout.session.completed`-Ereignis empfangen, können Sie mit [entitlements](https://docs.stripe.com/billing/entitlements.md) das Abo bereitstellen. Führen Sie die Bereitstellung monatlich fort (bei monatlicher Abrechnung), indem Sie auf die `invoice.paid`-Ereignisse reagieren. Erhalten Sie hingegen ein `invoice.payment_failed`-Ereignis, benachrichtigen Sie bitte Ihre Kundschaft und leiten Sie diese zum Kundenportal weiter, um die Zahlungsmethode zu aktualisieren. Um den nächsten Schritt für die Logik Ihres Systems zu bestimmen, überprüfen Sie den Ereignistyp und analysieren Sie die Payload jedes [Ereignisobjekts](https://docs.stripe.com/api/events/object.md), etwa `rechnung.paid`. Speichern Sie die IDs der Objekte `Abonnement` und `Kundin/Kunde` oder `Konto` zur Überprüfung in Ihrer Datenbank. Zu Testzwecken können Sie Ereignisse auf der [Registerkarte Ereignisse](https://dashboard.stripe.com/workbench/events) in [Workbench](https://docs.stripe.com/workbench.md) überwachen. Richten Sie für die Produktion einen Webhook-Endpoint ein und abonnieren Sie die entsprechenden Ereignistypen. Wenn Sie Ihren `STRIPE_WEBHOOK_SECRET`-Schlüssel nicht kennen, gehen Sie zur Zieldetailsansicht der [Registerkarte Webhooks](https://dashboard.stripe.com/workbench/webhooks) in Workbench, um ihn anzuzeigen. #### 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('<>') post '/webhook' do webhook_secret = '{{STRIPE_WEBHOOK_SECRET}}' # Beispiel: whsec_c7681Dm payload = request.body.read if !webhook_secret.empty? # Retrieve the event by verifying the signature using the raw body and secret if webhook signing is configured. sig_header = request.env['HTTP_STRIPE_SIGNATURE'] event = nil begin event = Stripe::Webhook.construct_event( payload, sig_header, webhook_secret ) rescue JSON::ParserError => e # Invalid payload status 400 return rescue Stripe::SignatureVerificationError => e # Invalid signature puts '⚠️ Webhook signature verification failed.' status 400 return end else data = JSON.parse(payload, symbolize_names: true) event = Stripe::Event.construct_from(data) end # Get the type of webhook event sent event_type = event['type'] data = event['data'] data_object = data['object'] case event_type when 'checkout.session.completed' # Payment is successful and the subscription is created. # Provision the subscription and save the customer ID to your database. when 'invoice.paid' # Continue to provision the subscription as payments continue to be made. # Store the status in your database and check when a customer accesses your service. # This approach helps you avoid hitting rate limits. when 'invoice.payment_failed' # The payment failed or the customer doesn't have a valid payment method. # The subscription becomes past_due. Notify your customer and send them to the # customer portal to update their payment information. else puts "Unhandled event type: \#{event.type}" end status 200 end ``` Überwachen Sie mindestens folgende Ereignistypen: | Ereignisname | Beschreibung | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | | `checkout.session.completed` | Wird gesendet, wenn ein/e Kund/in die Checkout-Sitzung erfolgreich abschließt, und informiert Sie über einen neuen Kauf. | | `invoice.paid` | Wird in jedem Rechnungsstellungszeitraum gesendet, wenn eine Zahlung erfolgreich ist. | | `invoice.payment_failed` | Wird in jedem Rechnungsstellungszeitraum gesendet, wenn es ein Problem mit der Zahlungsmethode Ihrer Kundin/Ihres Kunden gibt. | Weitere zu überwachende Ereignisse finden Sie unter [Abo-Webhooks](https://docs.stripe.com/billing/subscriptions/webhooks.md). ## Konfigurieren Sie das Kundenportal [Dashboard] Über das [Kundenportal](https://docs.stripe.com/customer-management.md) können Ihre Kund/innen ihre bestehenden Abos und Rechnungen direkt verwalten. Verwenden Sie das [Dashboard](https://dashboard.stripe.com/test/settings/billing/portal), um das Portal zu konfigurieren. [Konfigurieren Sie das Portal](https://docs.stripe.com/customer-management.md) mindestens so, dass Kundinnen und Kunden ihre Zahlungsmethoden aktualisieren können. ## Eine Portalsitzung erstellen [Server] Definieren Sie einen Endpoint, der [die Kundenportal-Sitzung erstellt](https://docs.stripe.com/api/customer_portal/sessions/create.md), die von Ihrem Frontend aufgerufen wird. Hier steht die von einer Checkout-Sitzung erstellte Kunden/Kundin, die Sie beim Verarbeiten des Webhooks `checkout.session.completed` gespeichert haben. Sie können auch im Dashboard einen Standard-Weiterleitungslink für das Portal festlegen. Übergeben Sie einen optionalen `return_url`-Wert für die Seite auf Ihrer Website, auf die Ihre Kund/innen nach der Verwaltung ihres Abos weitergeleitet werden: #### Accounts v2 #### 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('<>') # This is the URL that users are redirected to after they're done # managing their billing. return_url = '{{DOMAIN_URL}}' # Beispiel: http://example.com customer_account_id = '{{CUSTOMER_ACCOUNT_ID}}' # Beispiel: acct_GBV60HKsE0mb5v session = Stripe::BillingPortal::Session.create({ customer_account: customer_account_id, return_url: return_url, }) # Redirect to the URL for the session # redirect session.url, 303 ``` #### Customers v1 #### 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('<>') # This is the URL that users are redirected to after they're done # managing their billing. return_url = '{{DOMAIN_URL}}' # Beispiel: http://example.com customer_id = '{{CUSTOMER_ID}}' # Beispiel: cus_GBV60HKsE0mb5v session = client.v1.billing_portal.sessions.create({ customer: customer_id, return_url: return_url, }) # Redirect to the URL for the session # redirect session.url, 303 ``` ## Kunden zum Kundenportal senden [Client] Fügen Sie im Frontend eine Schaltfläche auf der Seite unter der `success_url` hinzu, die auf das Kundenportal verweist: ```html Manage Billing
``` Nach dem Verlassen des Kundenportals kehren die Kund/innen über die `return_url` auf Ihre Website zurück. Fahren Sie fort mit [Ereignisse überwachen](https://docs.stripe.com/billing/subscriptions/webhooks.md), um den Abo-Status der Kund/innen zu tracken. Wenn Sie das Kundenportal so konfigurieren, dass Aktionen wie die Kündigung eines Abos zugelassen werden, [überwachen Sie zusätzliche Ereignisse](https://docs.stripe.com/customer-management/integrate-customer-portal.md#webhooks). ## Testen Sie Ihre Integration. ### Zahlungsmethoden testen Verwenden Sie die folgende Tabelle, um verschiedene Zahlungsmethoden und -szenarien zu testen. | Zahlungsmethode | Szenario | So führen Sie den Test durch | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | BECS-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem BECS-Lastschriftverfahren. | Füllen Sie das Formular mit der Kontonummer `900123456` und BSB `000000` aus. Der bestätigte PaymentIntent geht zunächst in den Status `processing` über und dann drei Minuten später in den Status `succeeded`. | | BECS-Lastschrift | Die Zahlung Ihres/Ihrer Kund/in schlägt fehl mit Code `account_closed` fehl. | Füllen Sie das Formular mit der Kontonummer `111111113` und BSB `000000` aus. | | Kreditkarte | Die Kartenzahlung ist erfolgreich, und es ist keine Authentifizierung erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4242 4242 4242 4242` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | Kreditkarte | Für die Kartenzahlung ist eine *Authentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0025 0000 3155` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | Kreditkarte | Die Karte wird mit einem Ablehnungscode wie `insufficient_funds` abgelehnt. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0000 0000 9995` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | SEPA-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem SEPA-Lastschriftverfahren. | Füllen Sie das Formular mit der Kontonummer `AT321904300235473204` aus. Die bestätigte PaymentIntent geht zunächst in den Status „wird verarbeitet“ und dann drei Minuten später in den Status „erfolgreich“ über. | | SEPA-Lastschrift | Der Status der PaymentIntent Ihrer Kundin/Ihre Kundin wechselt von `processing` zu `requires_payment_method`. | Füllen Sie das Formular mit der Kontonummer `AT861904300235473202` aus. | ### Ereignisse überwachen Richten Sie Webhooks ein, um Änderungsereignisse für Abos wie Upgrades und Kündigungen zu überwachen. Sie können [Webhook-Ereignisse für Abos](https://docs.stripe.com/billing/subscriptions/webhooks.md) im [Dashboard](https://dashboard.stripe.com/test/events) oder mit [Stripe CLI](https://docs.stripe.com/webhooks.md#test-webhook) anzeigen. Erfahren Sie mehr über das [Testen Ihrer Abrechnungsintegration](https://docs.stripe.com/billing/testing.md). ## See also - [Kund/innen einen kostenlosen Testzeitraum anbieten](https://docs.stripe.com/billing/subscriptions/trials.md) - [Rabatte anwenden](https://docs.stripe.com/billing/subscriptions/coupons.md#using-coupons-in-checkout) - [Anteilmäßige Verrechnung verwalten](https://docs.stripe.com/billing/subscriptions/prorations.md) - [Berechtigungen integrieren, um den Zugriff auf die Funktionen Ihres Produkts zu verwalten](https://docs.stripe.com/billing/entitlements.md) # Vollständig eingebettete Seite > This is a Vollständig eingebettete Seite for when payment-ui is embedded-page. View the full page at https://docs.stripe.com/payments/checkout/build-subscriptions?payment-ui=embedded-page. # Vollständig eingebettete Seite > This is a Vollständig eingebettete Seite for when platform is web and ui is embedded-page. View the full page at https://docs.stripe.com/payments/checkout/build-subscriptions?platform=web&ui=embedded-page. #### Integrationsaufwand Complexity: 2/5 #### Anpassung der Nutzeroberfläche Passen Sie das Erscheinungsbild an. #### Integrationstyp Verwenden Sie vorgefertigte, integrierte Formulare, um Zahlungen einzuziehen und *Abonnements* (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) zu verwalten. ## Server einrichten ### Stripe einrichten 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' ``` ### Produkt und Preis erstellen [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 USD. Der Preis für das Premiumprodukt beträgt 15 USD. 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 USD - Basic-Produkt: Basic-Dienstleistung mit minimalem Funktionsumfang - Preis: Pauschalpreis | 5 USD 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 USD. 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": "usd", "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 } ``` Wenn Sie mehrere Rechnungsstellungszeiträume anbieten, verwenden Sie Checkout, um Kundinnen und Kunden längere Rechnungsstellungszeiträume als [Upsell](https://docs.stripe.com/payments/checkout/upsells.md) anzubieten und mehr Umsatz im Voraus zu erzielen. Weitere Preismodelle finden Sie unter [Abrechnungsbeispiele](https://docs.stripe.com/products-prices/pricing-models.md). ### Checkout-Sitzung erstellen Fügen Sie auf Ihrem Server einen Endpoint hinzu, der eine *Checkout-Sitzung* (A Checkout Session represents your customer's session as they pay for one-time purchases or subscriptions through Checkout. After a successful payment, the Checkout Session contains a reference to the Customer, and either the successful PaymentIntent or an active Subscription) erstellt. Übergeben Sie beim Erstellen der [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions/create.md) die folgenden Parameter: - Um die eingebettete Zahlungsseite zu verwenden, setzen Sie [ui_mode](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-ui_mode) auf `embedded_page`. - Um Abos beim Bezahlvorgang Ihrer Kundin/Ihres Kunden zu erstellen, setzen Sie [mode](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-mode) auf `subscription`. - Um die Seite zu definieren, zu der Ihre Kund/innen nach Abschluss bzw. Versuch der Zahlung zurückkehren, geben Sie eine [return_url](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-return_url) an. Fügen Sie die Vorlagenvariable `{CHECKOUT_SESSION_ID}` in die URL ein. Checkout ersetzt die Variable durch die `CheckoutSession`-ID, bevor Ihre Kund/innen weitergeleitet werden. Die Rückkehrseite erstellen und hosten Sie auf Ihrer Website. - Um Ihre Abonnement- und Kündigungsbedingungen sowie einen Link bereitzustellen, über den Ihre Kundinnen und Kunden ihr Abonnement aktualisieren oder kündigen können, verwenden Sie optional einen [benutzerdefinierten Text](https://docs.stripe.com/payments/checkout/custom-components.md?ui=embedded-page#customize-payment-method-reuse-agreement-and-subscription-terms). Wir empfehlen, [E-Mail-Erinnerungen und Benachrichtigungen](https://docs.stripe.com/invoicing/send-email.md#email-configuration) für Ihre Abonnentinnen und Abonnenten zu konfigurieren. Um Checkout zu verbinden, verwenden Sie das in der Antwort der Checkout-Sitzung zurückgegebene `client_secret`. ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=subscription \ -d "line_items[0][price]={{PRICE_ID}}" \ -d "line_items[0][quantity]=1" \ -d ui_mode=embedded_page \ --data-urlencode "return_url=https://example.com/checkout/return?session_id={CHECKOUT_SESSION_ID}" ``` ## Personalisierte Abonnementseite erstellen [Client] ### Checkout verbinden #### HTML + JS #### Stripe.js laden Verwenden Sie *Stripe.js* (Use Stripe.js’ APIs to tokenize customer information, collect sensitive card data, and accept payments with browser payment APIs), um *PCI-konform* (Any party involved in processing, transmitting, or storing credit card data must comply with the rules specified in the Payment Card Industry (PCI) Data Security Standards. PCI compliance is a shared responsibility and applies to both Stripe and your business) zu bleiben, indem Sie sicherstellen, dass die Zahlungsdaten ohne Umweg über Ihren Server direkt an Stripe gesendet werden. Laden Sie Stripe.js immer von js.stripe.com, um die Konformität zu gewährleisten. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie es nicht selbst. #### Zahlungsformular definieren Um die Kundeninformationen sicher zu erfassen, erstellen Sie den leeren Platzhalter `div`. Stripe fügt einen iFrame in `div` ein. Checkout ist als Teil von [Stripe.js](https://docs.stripe.com/js.md) verfügbar. Binden Sie das Stripe.js-Skript in Ihre Seite ein, indem Sie es zum Header Ihrer HTML-Datei hinzufügen. Als Nächstes erstellen Sie einen leeren DOM-Knoten (Container), der zum Verbinden verwendet wird. ```html Accept a payment
``` #### Stripe.js initialisieren Initialisieren Sie Stripe.js mit Ihrem veröffentlichungsfähigen API-Schlüssel. #### Client-Geheimnis der Checkout-Sitzung abrufen Erstellen Sie eine asynchrone `fetchClientSecret`-Funktion, die eine Anfrage an Ihren Server stellt, um [eine Checkout-Sitzung zu erstellen](https://docs.stripe.com/api/checkout/sessions/create.md) und das Client-Geheimnis abzurufen. #### Bezahlvorgang initialisieren Initialisieren Sie Checkout mit Ihrer `fetchClientSecret`-Funktion und verbinden Sie sie mit dem Platzhalter `
` in Ihrem Zahlungsformular. Checkout wird in einem iFrame gerendert, der Zahlungsinformationen sicher über eine HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, Checkout in einem anderen iFrame zu platzieren, da bei einigen Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung erforderlich ist. ```javascript // Initialize Stripe.js const stripe = Stripe('<>'); initialize(); // Fetch Checkout Session and retrieve the client secret async function initialize() { const fetchClientSecret = async () => { const response = await fetch("/create-checkout-session", { method: "POST", }); const { clientSecret } = await response.json(); return clientSecret; }; // Initialize Checkout const checkout = await stripe.createEmbeddedCheckoutPage({ fetchClientSecret, }); // Mount Checkout checkout.mount('#checkout'); } ``` #### React #### Stripe zu Ihrer React-App hinzufügen Installieren Sie [React Stripe.js](https://docs.stripe.com/sdks/stripejs-react.md), um die PCI-Konformität zu gewährleisten, indem sichergestellt wird, dass die Zahlungsdaten direkt an Stripe übermittelt werden und niemals auf Ihrem Server eingehen. ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` #### Stripe.js laden Um die Stripe-Bibliothek zu konfigurieren, rufen Sie `loadStripe()` mit Ihrem veröffentlichungsfähigen Stripe-API-Schlüssel auf. Erstellen Sie einen `EmbeddedCheckoutProvider`. Übergeben Sie das zurückgegebene `Promise` an den Anbieter. #### Client-Geheimnis der Checkout-Sitzung abrufen Erstellen Sie eine asynchrone `fetchClientSecret`-Funktion, die eine Anfrage an Ihren Server stellt, um [eine Checkout-Sitzung zu erstellen](https://docs.stripe.com/api/checkout/sessions/create.md) und das Client-Geheimnis abzurufen. #### Bezahlvorgang initialisieren Um den untergeordneten Komponenten den Zugriff auf den Stripe-Dienst über den Verbraucher des eingebetteten Checkouts zu ermöglichen, übergeben Sie das resultierende Promise von `loadStripe` und die Funktion `fetchClientSecret` als `option` an den Anbieter des eingebetteten Checkouts. ```jsx import * as React from 'react'; import {loadStripe} from '@stripe/stripe-js'; import { EmbeddedCheckoutProvider, EmbeddedCheckout } from '@stripe/react-stripe-js'; // Make sure to call `loadStripe` outside of a component's render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('pk_test_123', { }); const App = ({fetchClientSecret}) => { const options = {fetchClientSecret}; return ( ) } ``` ## Eine Rückkehrseite anzeigen Nachdem Ihre Kund/innen einen Zahlungsversuch unternommen haben, leitet Stripe sie auf eine Rückkehrseite weiter, die Sie auf Ihrer Website hosten. Als Sie die Checkout-Sitzung erstellt haben, haben Sie die URL der Rückkehrseite im Parameter [return_url](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-return_url) angegeben. > Während der Zahlung leiten einige Zahlungsmethoden die Kund/innen auf eine Zwischenseite weiter, zum Beispiel eine Bankautorisierungsseite. Wenn sie diese Seite ausgefüllt haben, leitet Stripe sie zu Ihrer Rückkehrseite weiter. #### Endpoint erstellen, um eine Checkout-Sitzung abzurufen Fügen Sie einen Endpoint hinzu, um den Status einer Checkout-Sitzung mit der Checkout-Sitzungs-ID in der URL abzurufen. #### Eine Checkout-Sitzung abrufen Um Details für die Checkout-Sitzung zu verwenden, stellen Sie sofort eine Anfrage an den Endpoint auf Ihrem Server, um mithilfe der Checkout-Sitzungs-ID in der URL den [Status der Checkout-Sitzung abzurufen](https://docs.stripe.com/api/checkout/sessions/retrieve.md), sobald Ihre Rückkehrseite geladen wird. #### Die Sitzung verarbeiten Das Ergebnis basierend auf dem Status der Sitzung verarbeiten: - `complete`: Die Zahlung war erfolgreich. Verwenden Sie die Informationen aus der Checkout-Sitzung, um eine Bestätigungsseite zu rendern. - `open`: Die Zahlung ist fehlgeschlagen oder wurde storniert. Stellen Sie erneut eine Verbindung zu Checkout her, damit Ihr/e Kund/in es nochmals versuchen kann. ```js // Retrieve a Checkout Session // Use the session ID initialize(); async function initialize() { const queryString = window.location.search; const urlParams = new URLSearchParams(queryString); const sessionId = urlParams.get('session_id'); const response = await fetch(`/session-status?session_id=${sessionId}`); const session = await response.json(); // Handle the session according to its status if (session.status == 'open') { // Remount embedded Checkout window.location.replace('http://localhost:4242/checkout.html') } else if (session.status == 'complete') { document.getElementById('success').classList.remove('hidden'); document.getElementById('customer-email').textContent = session.customer_email; // Show success page // Optionally use session.payment_status or session.customer_email // to customize the success page } } ``` #### Accounts v2 ```javascript // Add an endpoint to fetch the Checkout Session status app.get('/session_status', async (req, res) => { const session = await stripe.checkout.sessions.retrieve(req.query.session_id); const customer_account = await stripe.v2.core.accounts(session.customer_account); res.send({ status: session.status, payment_status: session.payment_status, customer_email: customer_account.contact_email }); }); ``` #### Customers v1 ```javascript // Add an endpoint to fetch the Checkout Session status app.get('/session_status', async (req, res) => { const session = await stripe.checkout.sessions.retrieve(req.query.session_id); const customer = await stripe.customers.retrieve(session.customer); res.send({ status: session.status, payment_status: session.payment_status, customer_email: customer.email }); }); ``` ## Optional: Konfigurieren Sie das Kundenportal Sie können das *Kundenportal* (The customer portal is a secure, Stripe-hosted page that lets your customers manage their subscriptions and billing details) einrichten, damit Ihre Kundinnen/Kunden ihre bestehenden Abonnements und Rechnungen direkt verwalten können. Sie können das Portal im Dashboard konfigurieren. Um die Abwanderung zu reduzieren, können Sie das Portal so konfigurieren, dass Kundinnen/Kunden ihre Zahlungsmethoden im Falle fehlgeschlagener Zahlungen aktualisieren können. Damit Ihre Kundinnen/Kunden das Kundenportal leichter finden und ihre Abonnements verwalten können, fügen Sie eine Schaltfläche auf Ihrer Website hinzu. Durch Anklicken dieser Schaltfläche werden diese zu der von Stripe gehosteten Kundenportal-Seite weitergeleitet. Erfahren Sie mehr über das [Kundenportal](https://docs.stripe.com/customer-management.md) und andere Optionen zur Kundenverwaltung. #### Eine Portalsitzung erstellen Um ein Kundenportal hinzuzufügen, definieren Sie einen Endpoint, der [die Kundenportal-Sitzung erstellt](https://docs.stripe.com/api/customer_portal/sessions/create.md), die von Ihrem Frontend aufgerufen wird. Hier steht die von einer Checkout-Sitzung erstellte Kunden/Kundin, die Sie beim Verarbeiten des Webhooks `checkout.session.completed` gespeichert haben. Sie können auch im Dashboard einen Standard-Weiterleitungslink für das Portal festlegen. Übergeben Sie einen optionalen `return_url`-Wert für die Seite auf Ihrer Website, auf die Ihre Kund/innen nach der Verwaltung ihres Abos weitergeleitet werden: #### Accounts v2 #### 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('<>') # This is the URL that users are redirected to after they're done # managing their billing. return_url = '{{DOMAIN_URL}}' # Beispiel: http://example.com customer_account_id = '{{CUSTOMER_ACCOUNT_ID}}' # Beispiel: acct_GBV60HKsE0mb5v session = Stripe::BillingPortal::Session.create({ customer_account: customer_account_id, return_url: return_url, }) # Redirect to the URL for the session # redirect session.url, 303 ``` #### Customers v1 #### 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('<>') # This is the URL that users are redirected to after they're done # managing their billing. return_url = '{{DOMAIN_URL}}' # Beispiel: http://example.com customer_id = '{{CUSTOMER_ID}}' # Beispiel: cus_GBV60HKsE0mb5v session = client.v1.billing_portal.sessions.create({ customer: customer_id, return_url: return_url, }) # Redirect to the URL for the session # redirect session.url, 303 ``` #### Kunden zum Kundenportal senden Fügen Sie im Frontend eine Schaltfläche auf der Seite unter der `success_url` hinzu, die auf das Kundenportal verweist: ```html Manage Billing
``` Nach dem Verlassen des Kundenportals kehren die Kund/innen über die `return_url` auf Ihre Website zurück. Fahren Sie fort mit [Ereignisse überwachen](https://docs.stripe.com/billing/subscriptions/webhooks.md), um den Abo-Status der Kund/innen zu tracken. Wenn Sie das Kundenportal so konfigurieren, dass Aktionen wie die Kündigung eines Abos zugelassen werden, achten Sie darauf, [zusätzliche Ereignisse](https://docs.stripe.com/customer-management/integrate-customer-portal.md#webhooks) zu überwachen. ## Zugriff bereitstellen Wenn das Abo aktiv ist, gewähren Sie Ihren Kund/innen Zugriff auf Ihren Dienst. Überwachen Sie dazu die Ereignisse `custom/Kundin.abonnement.created`, `custom/Kundin.abonnement.updated` und `custom/Kundin.abonnement.deleted` (auch wenn Sie von Kund/innen konfigurierte `Konten` verwenden). Diese Ereignisse übergeben ein `Abonnement`-Objekt, das ein `Status`-Feld enthält, das anzeigt, ob das Abo aktiv oder überfällig ist oder gekündigt wurde. Eine vollständige Statusliste finden Sie im [Abonnement Lebenszyklus](https://docs.stripe.com/billing/subscriptions/overview.md#subscription-lifecycle). Um den Zugriff auf die Funktion Ihres Produkts zu verwalten, informieren Sie sich über die [Integration von Berechtigungen](https://docs.stripe.com/billing/entitlements.md). In Ihrem Webhook-Handler: 1. Überprüfen Sie den Status des Abos. Wenn er `aktiv` ist, hat der/die Kunde/Kundin für Ihr Produkt bezahlt. 1. Prüfen Sie das Produkt, das die Kundin/der Kunde abonniert hat, und gewähren Sie Zugang zu Ihrem Dienst. Das Überprüfen des Produkts anstelle des Preises gibt Ihnen mehr Flexibilität, falls Sie die Preisgestaltung oder den Rechnungsstellungszeitraum ändern müssen. 1. Speichern Sie die `product.id`, `Abonnement.id` und den `Abonnement.status` in Ihrer Datenbank zusammen mit der bereits gespeicherten `customer_account.id` oder der `customer.id`. Überprüfen Sie diesen Datensatz, wenn Sie entscheiden, welche Funktionen für die Nutzer/innen Ihrer Anwendung aktiviert werden sollen. Der Status eines Abos kann sich während seiner Laufzeit jederzeit ändern, auch wenn Ihre Anwendung keine direkten Aufrufe an Stripe tätigt. So kann beispielsweise eine Verlängerung aufgrund einer abgelaufenen Karte fehlschlagen, wodurch das Abo in einen überfälligen Status versetzt wird. Oder, wenn Sie das [Kundenportal](https://docs.stripe.com/customer-management.md) implementieren, könnte ein/e Nutzer/in das Abo kündigen, ohne Ihre Anwendung direkt aufzurufen. Durch die korrekte Implementierung Ihres Handlers bleibt der Status Ihrer Anwendung mit Stripe synchronisiert. ## Testen Sie Ihre Integration. ### Zahlungsmethoden testen Verwenden Sie die folgende Tabelle, um verschiedene Zahlungsmethoden und -szenarien zu testen. | Zahlungsmethode | Szenario | So führen Sie den Test durch | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | BECS-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem BECS-Lastschriftverfahren. | Füllen Sie das Formular mit der Kontonummer `900123456` und BSB `000000` aus. Der bestätigte PaymentIntent geht zunächst in den Status `processing` über und dann drei Minuten später in den Status `succeeded`. | | BECS-Lastschrift | Die Zahlung Ihres/Ihrer Kund/in schlägt fehl mit Code `account_closed` fehl. | Füllen Sie das Formular mit der Kontonummer `111111113` und BSB `000000` aus. | | Kreditkarte | Die Kartenzahlung ist erfolgreich, und es ist keine Authentifizierung erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4242 4242 4242 4242` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | Kreditkarte | Für die Kartenzahlung ist eine *Authentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0025 0000 3155` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | Kreditkarte | Die Karte wird mit einem Ablehnungscode wie `insufficient_funds` abgelehnt. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0000 0000 9995` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | SEPA-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem SEPA-Lastschriftverfahren. | Füllen Sie das Formular mit der Kontonummer `AT321904300235473204` aus. Die bestätigte PaymentIntent geht zunächst in den Status „wird verarbeitet“ und dann drei Minuten später in den Status „erfolgreich“ über. | | SEPA-Lastschrift | Der Status der PaymentIntent Ihrer Kundin/Ihre Kundin wechselt von `processing` zu `requires_payment_method`. | Füllen Sie das Formular mit der Kontonummer `AT861904300235473202` aus. | ### Ereignisse überwachen Richten Sie Webhooks ein, um Änderungsereignisse für Abos wie Upgrades und Kündigungen zu überwachen. Sie können [Webhook-Ereignisse für Abos](https://docs.stripe.com/billing/subscriptions/webhooks.md) im [Dashboard](https://dashboard.stripe.com/test/events) oder mit [Stripe CLI](https://docs.stripe.com/webhooks.md#test-webhook) anzeigen. Erfahren Sie mehr über das [Testen Ihrer Abrechnungsintegration](https://docs.stripe.com/billing/testing.md).