# Alipay-Zahlung annehmen Erfahren Sie, wie Sie Alipay-Zahlungen annehmen, einer bei Kund/innen aus China beliebten digitalen Geldbörse. # Bezahlvorgang > This is a Bezahlvorgang for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/alipay/accept-a-payment?payment-ui=checkout. > Stripe kann Ihren Kundinnen und Kunden automatisch die relevanten Zahlungsmethoden anzeigen, indem Währungen, Einschränkungen der Zahlungsmethode und andere Parameter ausgewertet werden. > > - Befolgen Sie den Leitfaden [Eine Zahlung akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted), um eine Checkout-Integration zu erstellen, die [dynamische Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) verwendet. - Wenn Sie keine dynamischen Zahlungsmethoden verwenden möchten, befolgen Sie die folgenden Schritte, um die Zahlungsmethoden in Ihrer Checkout-Integration manuell zu konfigurieren. Bei Alipay handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden ihre Zahlungen [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei Zahlungen werden Kundinnen/Kunden zur Autorisierung der Zahlung mit Alipay von Ihrer Website weggeleitet und dann wieder auf Ihre Website zurückgeleitet, wo Sie eine [sofortige Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) über den Erfolg oder das Fehlschlagen der Zahlung erhalten. ## Kompatibilität bestimmen **Kundenregion**: China **Unterstützte Währungen**: `aud, cad, eur, gbp, hkd, jpy, nzd, sgd, usd, myr` **Transaktionswährungen**: `aud, cad, cny, eur, gbp, hkd, jpy, nzd, sgd, usd, myr` **Zahlungsmodus**: Yes **Einrichtungsmodus**: No **Abonnementmodus**: No Für die Unterstützung von Alipay-Zahlungen muss eine Checkout-Sitzung alle folgenden Bedingungen erfüllen: - Die *Preise* (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) für alle Posten müssen in der gleichen Währung angegeben werden. - Wenn Sie mehrere Posten in der verschiedenen Währungen haben, erstellen Sie getrennte Checkout-Sitzungen für jede Währung. - Sie können nur einmalige Posten verwenden. Wiederkehrende *Abonnementpläne* (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) werden nicht unterstützt. ## Zahlung annehmen > Erstellen Sie zunächst eine Integration, um mit Checkout [Zahlungen anzunehmen](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout), bevor Sie mit diesem Leitfaden fortfahren. Diese Anleitung zeigt Ihnen, wie Sie Alipay aktivieren und erklärt die Unterschiede zwischen der Annahme von Zahlungen über dynamische Zahlungsmethoden und der manuellen Konfiguration von Zahlungsmethoden. ### Alipay als Zahlungsmethode aktivieren Führen Sie bei der Erstellung einer neuen [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) folgende Schritte aus: 1. Fügen Sie `Alipay` der Liste der `payment_method_types` hinzu. 1. Stellen Sie sicher, dass alle `line_items` die gleiche Währung verwenden. #### Von Stripe gehostete Seite ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=hkd" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d mode=payment \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=alipay" \ --data-urlencode "success_url=https://example.com/success" ``` #### Eingebettetes Formular ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=hkd" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d mode=payment \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=alipay" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=embedded_page ``` ### Abwicklung Ihrer Bestellungen Informieren Sie sich über die [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md), nachdem Sie eine Zahlung angenommen haben. ## Integration testen Wählen Sie beim Testen Ihrer Checkout-Integration Alipay als Zahlungsmethode aus und klicken Sie auf die Schaltfläche **Bezahlen**. ## Mit Rückerstattungen und angefochtenen Zahlungen umgehen Das Rückerstattungszeitfenster für Alipay beträgt bis zu 90 Tage nach der ursprünglichen Zahlung. Bei Alipay gibt es kein Verfahren für angefochtene Zahlungen. Kund/innen authentifizieren sich über ihr Alipay-Konto. ## See also - [Weitere Infos zu Alipay](https://docs.stripe.com/payments/alipay.md) - [Checkout-Ausführung](https://docs.stripe.com/checkout/fulfillment.md) - [Checkout anpassen](https://docs.stripe.com/payments/checkout/customization.md) # iOS > This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/alipay/accept-a-payment?payment-ui=mobile&platform=ios. Bei Alipay handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden ihre Zahlungen [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei Zahlungen werden Kundinnen/Kunden zur Autorisierung der Zahlung mit Alipay von Ihrer Website weggeleitet und dann wieder auf Ihre Website zurückgeleitet, wo Sie eine [sofortige Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) über den Erfolg oder das Fehlschlagen der Zahlung erhalten. ## Stripe einrichten [Clientseitig] [Serverseitig] Als Erstes benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13 oder höher unterstützen. #### Swift Package Manager Führen Sie zur Installation des SDK die folgenden Schritte aus: 1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein. 1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus. 1. Fügen Sie das Produkt **StripePaymentsUI** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu. #### CocoaPods 1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen: ```bash pod init ``` 1. Fügen Sie folgende Zeile in Ihre `Podfile` ein: ```podfile pod 'StripePaymentsUI' ``` 1. Führen Sie folgenden Befehl aus: ```bash pod install ``` 1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden. 1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus: ```bash pod update StripePaymentsUI ``` #### Carthage 1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein: ```cartfile github "stripe/stripe-ios" ``` 1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks einbetten. 1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus: ```bash carthage update stripe-ios --platform ios ``` #### Manuelles Framework 1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei. 1. Ziehen Sie **StripePaymentsUI.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig). 1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks. 1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3. > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/test/apikeys) von Stripe, um es beim Start der App auszuführen. Dadurch kann Ihre App Anfragen an die Stripe-API senden. #### Swift ```swift import UIKitimportStripePaymentsUI @main class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<>" // do any other necessary launch configuration return true } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ## PaymentIntent erstellen [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von Ihrem Kunden/Ihrer Kundin einzuziehen und verfolgt den Lebenszyklus des Zahlungsvorgangs. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und eine [unterstützte Währung](https://docs.stripe.com/payments/alipay.md#supported-currencies) an. Wenn Sie über eine bestehende [Payment Intents](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `alipay` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=alipay" \ -d amount=1099 \ -d currency=hkd ``` ## An das Alipay-Wallet weiterleiten [Clientseitig] [Registrieren Sie ein benutzerdefiniertes URL-Schema für Ihre App](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app), indem Sie zur Registerkarte „Info“ Ihrer App-Zieleinstellungen wechseln. ![Benutzerdefiniertes URL-Schema in Xcode einrichten](https://b.stripecdn.com/docs-statics-srv/assets/ios-custom-url-scheme.e7bbf5f60cbb1a96f157f5cd89410120.png) Die Alipay-App öffnet diese URL für die Rückkehr zur Ihrer App, nachdem der/die Kund/in die Zahlung abgeschlossen hat. Leiten Sie die URL an das Stripe SDK in Ihrem `UISceneDelegate` oder `UIApplicationDelegate` weiter: #### SceneDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func scene(_ scene: UIScene, openURLContexts URLContexts: Set) { guard let url = URLContexts.first?.url else { return } let stripeHandled = StripeAPI.handleURLCallback(with: url) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } ``` #### AppDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool { let stripeHandled = StripeAPI.handleURLCallback(with: url) if (stripeHandled) { return true } else { // This was not a Stripe url – handle the URL normally as you would } return false } ``` Wenn der/die Kund/in auf die Schaltfläche zum Bezahlen mit Alipay klickt, bestätigen Sie die PaymentIntent mit [STPPaymentHandler confirmPayment](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:). Dadurch wird die Alipay App gestartet oder eine Webansicht angezeigt, wenn die Alipay App nicht installiert ist. #### Swift ```swift import UIKit import StripePayments class CheckoutViewController: UIViewController { // ... func pay() { let clientSecret = ... // The client secret of the PaymentIntent let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret) paymentIntentParams.paymentMethodParams = STPPaymentMethodParams(alipay: STPPaymentMethodAlipayParams(), billingDetails: nil, metadata: nil) paymentIntentParams.paymentMethodOptions = STPConfirmPaymentMethodOptions() paymentIntentParams.paymentMethodOptions?.alipayOptions = STPConfirmAlipayOptions() paymentIntentParams.returnURL = "{{URL SCHEME}}://safepay/" // Replace {{URL SCHEME}} with your own custom URL scheme. STPPaymentHandler.shared().confirmPayment(paymentIntentParams, with: self) { (status, intent, error) in switch status { case .canceled: // Payment was canceled case .failed: // Payment failed case .succeeded: // Payment was successful @unknown default: fatalError() } } } } extension CheckoutViewController: STPAuthenticationContext { func authenticationPresentingViewController() -> UIViewController { return self } } ``` Alipay öffnet die Rückgabe-URL mit `safepay/` als Host. Beispiel: Wenn Ihr benutzerdefiniertes URL-Schema `myapp` ist, muss Ihre Rückgabe-URL `myapp://safepay/` lauten. ## Optional: Ereignisse nach Zahlung verarbeiten Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs). Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. ## Unterstützte Währungen Ihr Konto muss über ein Bankkonto für eine der folgenden Währungen verfügen. Sie können Alipay Zahlungen in den Währungen erstellen, die Ihrem Land zugeordnet sind. Die standardmäßige lokale Währungen für Alipay ist `cny` und Kund/innen sehen ihren Kaufbetrag auch in `cny`. | Währung | Land | | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `cny` | Beliebiges Land | | `aud` | Australien | | `cad` | Kanada | | `eur` | Österreich, Belgien, Bulgarien, Zypern, Tschechien, Dänemark, Estland, Finnland, Frankreich, Deutschland, Griechenland, Irland, Italien, Lettland, Litauen, Luxemburg, Malta, Niederlande, Norwegen, Portugal, Rumänien, Slowakei, Slowenien, Spanien, Schweden, Schweiz | | `gbp` | Vereinigtes Königreich | | `hkd` | Hongkong | | `jpy` | Japan | | `myr` | Malaysia | | `nzd` | Neuseeland | | `sgd` | Singapur | | `usd` | USA | Wenn Sie ein Konto in einer anderen Währung haben und eine Alipay Zahlung in dieser Währung erstellen möchten, können Sie sich [an den Kund/innen-Support](https://support.stripe.com/email) wenden. Wir unterstützen gegebenenfalls weitere Währungen je nach Fall. # Android > This is a Android for when payment-ui is mobile and platform is android. View the full page at https://docs.stripe.com/payments/alipay/accept-a-payment?payment-ui=mobile&platform=android. Bei Alipay handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden ihre Zahlungen [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei Zahlungen werden Kundinnen/Kunden zur Autorisierung der Zahlung mit Alipay von Ihrer Website weggeleitet und dann wieder auf Ihre Website zurückgeleitet, wo Sie eine [sofortige Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) über den Erfolg oder das Fehlschlagen der Zahlung erhalten. ## Stripe einrichten [Serverseitig] [Clientseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie diese offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/). Um das SDK zu installieren, fügen Sie `stripe-android` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein: #### Kotlin ```kotlin plugins { id("com.android.application") } android { ... } dependencies { // ... // Stripe Android SDK implementation("com.stripe:stripe-android:23.2.0") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.2.0") } ``` > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/apikeys) von Stripe so, dass dieser Anfragen an die API stellen kann, wie beispielsweise in Ihrer Unterklasse `Application`: #### Kotlin ```kotlin import com.stripe.android.PaymentConfiguration class MyApp : Application() { override fun onCreate() { super.onCreate() PaymentConfiguration.init( applicationContext, "<>" ) } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. Stripe-Beispiele nutzen auch [OkHttp](https://github.com/square/okhttp) und [GSON](https://github.com/google/gson), um HTTP-Anfragen an einen Server zu stellen. ## Integration des Alipay SDK [Clientseitig] Für In-App-Zahlungen mit dem App-zu-App-Weiterleitungsablauf von Alipay müssen Sie das [Alipay SDK](https://global.alipay.com/docs/ac/app/download) integrieren. Wenn Sie das Alipay SDK integrieren möchten, nutzt das Stripe SDK eine WebView, um Kund/innen an Alipay weiterzuleiten. Durch die Integration des Alipay SDK erhalten Sie ein nahtloseres Nutzererlebnis für Ihre Kund/innen, wobei jedoch die Gesamtgröße Ihrer App erhöht wird. Weitere Informationen finden Sie unter [WebView verwenden](https://docs.stripe.com/payments/alipay/accept-a-payment.md#android-using-a-webview). Nachdem Sie das Archiv dekomprimiert haben, fügen Sie `alipaySdk-{version}.aar` dem Verzeichnis `libs` Ihrer App hinzu. Fügen Sie den Ordner `libs` der Repository-Liste der Abhängigkeiten in Ihrem Projekt hinzu: ```groovy allprojects { repositories { flatDir { dirs 'libs' } } } ``` Fügen Sie die Abhängigkeit Ihrer App hinzu: ```groovy dependencies { // ... // Replace {version} with the version number of the Alipay SDK that you downloaded above implementation(name:"alipaySdk-{version}", ext:"aar") } ``` ## PaymentIntent erstellen [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von Ihrem Kunden/Ihrer Kundin einzuziehen und verfolgt den Lebenszyklus des Zahlungsvorgangs. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und eine [unterstützte Währung](https://docs.stripe.com/payments/alipay.md#supported-currencies) an. Wenn Sie über eine bestehende [Payment Intents](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `alipay` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=alipay" \ -d amount=1099 \ -d currency=hkd ``` ## An das Alipay-Wallet weiterleiten [Clientseitig] Fordern Sie eine PaymentIntent vom Server an und speichern Sie ihr Client-Geheimnis. #### Kotlin ```kotlin class AlipayActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { // ... fetchPaymentIntent() } private fun fetchPaymentIntent() { // Request a PaymentIntent from your server and store its client secret } } ``` Wenn der/die Kund/in auf die Schaltfläche zum Bezahlen mit Alipay klickt, bestätigen Sie PaymentIntent mit `confirmAlipayPayment` von Stripe. Sie müssen einen AlipayAuthenticator bereitstellen, um Daten vom Stripe SDK zum Alipay SDK zu übergeben. Der Authenticator ruft die Alipay-Methode `payV2` mit der übergebenen Datenzeichenfolge auf. Das Alipay SDK öffnet die Alipay-App (sofern installiert) oder zeigt seine eigene Benutzeroberfläche an und übermittelt das Ergebnis automatisch zurück an das Stripe SDK. > Das Alipay Android SDK unterstützt keine Testzahlungen. Verwenden Sie den [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes), um diese Integration vollständig zu testen. #### Kotlin ```kotlin import com.alipay.sdk.app.PayTask class AlipayActivity : AppCompatActivity() { // ... private lateinit var paymentIntentClientSecret: String private val stripe: Stripe by lazy { Stripe( applicationContext, PaymentConfiguration.getInstance(applicationContext).publishableKey ) } // Call this function when the customer taps "Pay with Alipay" private fun startCheckout() { // ... lifecycleScope.launch { runCatching { stripe.confirmAlipayPayment( ConfirmPaymentIntentParams.createAlipay(paymentIntentClientSecret), { data -> PayTask(this@AlipayActivity).payV2(data, true) } ) }.fold( onSuccess = { result -> val paymentIntent = result.intent val status = paymentIntent.status when (status) { StripeIntent.Status.Succeeded -> { // Payment succeeded } StripeIntent.Status.RequiresAction -> { // Customer didn't complete the payment // You can try to confirm this Payment Intent again } else -> { // Payment failed/canceled } } }, onFailure = { // Payment failed } ) } } } ``` ## Optional: WebView verwenden [Clientseitig] Wenn Sie das Alipay SDK nicht integrieren möchten, kann das Stripe SDK den/die Kund/in an eine Alipay WebView weiterleiten, wenn Sie `confirmPayment` aufrufen. Die Alipay-Website öffnet die Alipay-App (sofern installiert) oder bietet Kund/innen die Möglichkeit, die Zahlung im Web abzuschließen. #### Kotlin ```kotlin class AlipayActivity : AppCompatActivity() { // ... private lateinit var paymentIntentClientSecret: String private val stripe: Stripe by lazy { Stripe( applicationContext, PaymentConfiguration.getInstance(applicationContext).publishableKey ) } // Call this method when the customer taps "Pay with Alipay" private fun startCheckout() { // ... val confirmParams = ConfirmPaymentIntentParams.createAlipay(paymentIntentClientSecret) stripe.confirmPayment(this, confirmParams) } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { super.onActivityResult(requestCode, resultCode, data) // Handle the result of stripe.confirmPayment stripe.onPaymentResult(requestCode, data, object : ApiResultCallback { override fun onSuccess(result: PaymentIntentResult) { val paymentIntent = result.intent val status = paymentIntent.status when (status) { StripeIntent.Status.Succeeded -> { // Payment succeeded } StripeIntent.Status.RequiresAction -> { // Customer didn't complete the payment // You can try to confirm this Payment Intent again } else -> { // Payment failed/canceled } } } override fun onError(e: Exception) { // Payment failed } }) } } ``` ## Optional: Ereignisse nach Zahlung verarbeiten Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs). Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. ## Unterstützte Währungen Ihr Konto muss über ein Bankkonto für eine der folgenden Währungen verfügen. Sie können Alipay Zahlungen in den Währungen erstellen, die Ihrem Land zugeordnet sind. Die standardmäßige lokale Währungen für Alipay ist `cny` und Kund/innen sehen ihren Kaufbetrag auch in `cny`. | Währung | Land | | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `cny` | Beliebiges Land | | `aud` | Australien | | `cad` | Kanada | | `eur` | Österreich, Belgien, Bulgarien, Zypern, Tschechien, Dänemark, Estland, Finnland, Frankreich, Deutschland, Griechenland, Irland, Italien, Lettland, Litauen, Luxemburg, Malta, Niederlande, Norwegen, Portugal, Rumänien, Slowakei, Slowenien, Spanien, Schweden, Schweiz | | `gbp` | Vereinigtes Königreich | | `hkd` | Hongkong | | `jpy` | Japan | | `myr` | Malaysia | | `nzd` | Neuseeland | | `sgd` | Singapur | | `usd` | USA | Wenn Sie ein Konto in einer anderen Währung haben und eine Alipay Zahlung in dieser Währung erstellen möchten, können Sie sich [an den Kund/innen-Support](https://support.stripe.com/email) wenden. Wir unterstützen gegebenenfalls weitere Währungen je nach Fall. # React Native > This is a React Native for when payment-ui is mobile and platform is react-native. View the full page at https://docs.stripe.com/payments/alipay/accept-a-payment?payment-ui=mobile&platform=react-native. Bei Alipay handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden ihre Zahlungen [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei Zahlungen werden Kundinnen/Kunden zur Autorisierung der Zahlung mit Alipay von Ihrer Website weggeleitet und dann wieder auf Ihre Website zurückgeleitet, wo Sie eine [sofortige Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) über den Erfolg oder das Fehlschlagen der Zahlung erhalten. ## Stripe einrichten [Serverseitig] [Clientseitig] ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [React Native SDK](https://github.com/stripe/stripe-react-native) ist Open Source und vollständig dokumentiert. Intern werden [native iOS](https://github.com/stripe/stripe-ios) und [Android](https://github.com/stripe/stripe-android) SDKs verwendet. Um das React Native SDK von Stripe zu installieren, führen Sie einen der folgenden Befehle im Verzeichnis Ihres Projekts aus (je nachdem, welchen Paket-Manager Sie verwenden): #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Installieren Sie als Nächstes einige weitere erforderliche Abhängigkeiten: - Für iOS wechseln Sie in das Verzeichnis **ios** und führen Sie `pod install` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Dependencies installiert haben. - Für Android müssen keine Abhängigkeiten mehr installiert werden. > Wir empfehlen Ihnen, die [offizielle Anleitung zu TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) zu befolgen, um TypeScript zu unterstützen. ### Stripe Initialisierung Um Stripe in Ihrer React Native-App zu initialisieren, umschließen Sie entweder Ihren Zahlungsbildschirm mit der Komponente `StripeProvider` oder verwenden Sie die Initialisierungsmethode `initStripe`. Nur der [veröffentlichbare API-Schlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) in `publishableKey` ist erforderlich. Das folgende Beispiel zeigt, wie Stripe mithilfe der Komponente `StripeProvider` initialisiert wird. ```jsx import { useState, useEffect } from 'react'; import { StripeProvider } from '@stripe/stripe-react-native'; function App() { const [publishableKey, setPublishableKey] = useState(''); const fetchPublishableKey = async () => { const key = await fetchKey(); // fetch key from your server here setPublishableKey(key); }; useEffect(() => { fetchPublishableKey(); }, []); return ( {/* Your app code here */} ); } ``` > Verwenden Sie Ihre API-[Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ## PaymentIntent erstellen [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von Ihrem Kunden/Ihrer Kundin einzuziehen und verfolgt den Lebenszyklus des Zahlungsvorgangs. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und eine [unterstützte Währung](https://docs.stripe.com/payments/alipay.md#supported-currencies) an. Wenn Sie über eine bestehende [Payment Intents](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `alipay` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=alipay" \ -d amount=1099 \ -d currency=hkd ``` ## An das Alipay-Wallet weiterleiten [Clientseitig] Das Stripe React Native SDK gibt `safepay/` als Host für die Rückgabe-URL für Zahlungsmethoden mit Bankweiterleitung und digitaler Geldbörse an. Nachdem Kund/innen die Zahlung mit Alipay abgeschlossen haben, werden sie an `myapp://safepay/` weitergeleitet, wobei `myapp` Ihr benutzerdefiniertes URL-Schema ist. Wenn Kundinnen/Kunden Ihre App verlassen (zum Beispiel um sich in Safari oder ihrer Banking-App zu authentifizieren), bieten Sie ihnen eine Möglichkeit, automatisch zu Ihrer App zurückzukehren. Für viele Arten von Zahlungsmethoden *ist* eine Rückgabe-URL erforderlich. Wenn Sie keine angeben, können wir Ihren Nutzer/innen keine Zahlungsmethoden anbieten, für die eine Rückgabe-URL erforderlich ist, selbst wenn Sie diese aktiviert haben. So geben Sie eine Rückgabe-URL an: 1. [Registrieren](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) Sie eine benutzerdefinierte URL. Universelle Links werden nicht unterstützt. 1. [Konfigurieren](https://reactnative.dev/docs/linking) Sie Ihre benutzerdefinierte URL. 1. Richten Sie Ihre Root-Komponente so ein, dass sie die URL an das Stripe SDK weitergibt, wie unten gezeigt. > Wenn Sie Expo verwenden, [stellen Sie Ihr Schema](https://docs.expo.io/guides/linking/#in-a-standalone-app) in der Datei `app.json` ein. ```jsx import { useEffect, useCallback } from 'react'; import { Linking } from 'react-native'; import { useStripe } from '@stripe/stripe-react-native'; export default function MyApp() { const { handleURLCallback } = useStripe(); const handleDeepLink = useCallback( async (url: string | null) => { if (url) { const stripeHandled = await handleURLCallback(url); if (stripeHandled) { // This was a Stripe URL - you can return or add extra handling here as you see fit } else { // This was NOT a Stripe URL – handle as you normally would } } }, [handleURLCallback] ); useEffect(() => { const getUrlAsync = async () => { const initialUrl = await Linking.getInitialURL(); handleDeepLink(initialUrl); }; getUrlAsync(); const deepLinkListener = Linking.addEventListener( 'url', (event: { url: string }) => { handleDeepLink(event.url); } ); return () => deepLinkListener.remove(); }, [handleDeepLink]); return ( ); } ``` Weitere Informationen zu nativen URL-Schemen finden Sie in der Dokumentation für [Android](https://developer.android.com/training/app-links/deep-linking) und [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app). ## Zahlung bestätigen [Clientseitig] Wenn der/die Kund/in auf die Schaltfläche zum Bezahlen mit Alipay klickt, rufen Sie `confirmPayment` auf, um eine Webansicht anzuzeigen, in der die Kund/innen die Zahlung abschließen können. ```javascript export default function AlipayPaymentScreen() { const [email, setEmail] = useState(''); const { confirmPayment, loading } = useConfirmPayment(); const handlePayPress = async () => { const { clientSecret } = await fetchPaymentIntentClientSecret(); const { error, paymentIntent } = await confirmPayment(clientSecret, { paymentMethodType: 'Alipay', }); if (error) { Alert.alert(`Error code: ${error.code}`, error.message); } else if (paymentIntent) { Alert.alert( 'Success', `The payment was confirmed successfully! currency: ${paymentIntent.currency}` ); } }; return ( setEmail(value.nativeEvent.text)} /> ``` ```ruby get '/checkout' do @intent = # ... Fetch or create the PaymentIntent erb :checkout end ``` ## An das Alipay-Wallet weiterleiten [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit Alipay bezahlen, verwenden Sie Stripe.js, um die Zahlungen an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist die grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie verarbeitet automatisch komplexe Szenarien wie die nachfolgend beschriebene Weiterleitung und ermöglicht die Erweiterung Ihrer Integration durch zusätzliche Zahlungsmethoden. Binden Sie das Stripe.js-Skript in Ihre Bezahlseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen. ```html Checkout ``` Erstellen Sie auf Ihrer Checkout-Seite mit dem folgenden JavaScript eine Instanz von Stripe.js. ```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('<>'); ``` Verwenden Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent` und rufen Sie `stripe.confirmAlipayPayment` auf, um die Alipay-Weiterleitung zu handhaben. Fügen Sie eine `return_url` hinzu, um festzulegen, wohin Stripe den Kunden/die Kundin weiterleitet, nachdem er/sie die Zahlung abgeschlossen hat. ```javascript const form = document.getElementById('payment-form'); form.addEventListener('submit', async function(event) { event.preventDefault(); // Set the clientSecret of the PaymentIntent const { error } = await stripe.confirmAlipayPayment(clientSecret, { // Return URL where the customer should be redirected after the authorization return_url: `${window.location.href}`, }); if (error) { // Inform the customer that there was an error. const errorElement = document.getElementById('error-message'); errorElement.textContent = error.message; } }); ``` Die `return_url` verweist auf eine Seite auf Ihrer Website, auf der das Ergebnis der Zahlung angezeigt wird. Durch [Verifizieren des Status](https://docs.stripe.com/payments/payment-intents/verifying-status.md#checking-status) des `PaymentIntent` können Sie festlegen, was angezeigt werden soll. Zur Verifizierung des Status enthält die Stripe-Weiterleitung zu der `return_url` die folgenden URL-Abfrageparameter. Sie können auch Ihre eigenen Abfrageparameter an die `return_url` anhängen. Diese bleiben während des gesamten Weiterleitungsprozesses bestehen. | Parameter | Beschreibung | | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent` | Die eindeutige ID für `PaymentIntent`. | | `payment_intent_client_secret` | Das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent`-Objekts. | ## Optional: Weiterleitung manuell handhaben [Serverseitig] Wir empfehlen, die Verarbeitung von Weiterleitungen mit `confirmAlipayPayment` Stripe.js zu überlassen. Wenn Sie Ihre Kund/innen jedoch manuell weiterleiten müssen: 1. Geben Sie die URL an, an die Ihre Kund/innen weitergeleitet werden sollen, sobald die Zahlung abgeschlossen ist. ```curl curl https://api.stripe.com/v1/payment_intents/pi_1DRuHnHgsMRlo4MtwuIAUe6u/confirm \ -u "<>:" \ -d payment_method=pm_1EnPf7AfTbPYpBIFLxIc8SD9 \ --data-urlencode "return_url=https://shop.example.com/crtA6B28E1" ``` 1. Bestätigen Sie, dass der `PaymentIntent` sich im Status `requires_action` befindet. Der Typ für `next_action` ist `alipay_handle_redirect`. ```json "next_action": { "type": "alipay_handle_redirect", "alipay_handle_redirect": { "url": "https://hooks.stripe.com/...", "return_url": "https://example.com/checkout/complete" } } ``` 1. Leiten Sie die Kundin/den Kunden an die in der Eigenschaft `next_action` angegebene URL weiter. Bei Abschluss des Bezahlvorgangs werden die Kund/innen an das Ziel `return_url` weitergeleitet. Die URL-Abfrageparameter `payment_intent` und `payment_intent_client_secret` sind enthalten und Sie können wie oben beschrieben Ihre eigenen Abfrageparameter übergeben. ## Optional: Ereignisse nach Zahlung verarbeiten Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs). Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. ## Unterstützte Währungen Ihr Konto muss über ein Bankkonto für eine der folgenden Währungen verfügen. Sie können Alipay Zahlungen in den Währungen erstellen, die Ihrem Land zugeordnet sind. Die standardmäßige lokale Währungen für Alipay ist `cny` und Kund/innen sehen ihren Kaufbetrag auch in `cny`. | Währung | Land | | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `cny` | Beliebiges Land | | `aud` | Australien | | `cad` | Kanada | | `eur` | Österreich, Belgien, Bulgarien, Zypern, Tschechien, Dänemark, Estland, Finnland, Frankreich, Deutschland, Griechenland, Irland, Italien, Lettland, Litauen, Luxemburg, Malta, Niederlande, Norwegen, Portugal, Rumänien, Slowakei, Slowenien, Spanien, Schweden, Schweiz | | `gbp` | Vereinigtes Königreich | | `hkd` | Hongkong | | `jpy` | Japan | | `myr` | Malaysia | | `nzd` | Neuseeland | | `sgd` | Singapur | | `usd` | USA | Wenn Sie ein Konto in einer anderen Währung haben und eine Alipay Zahlung in dieser Währung erstellen möchten, können Sie sich [an den Kund/innen-Support](https://support.stripe.com/email) wenden. Wir unterstützen gegebenenfalls weitere Währungen je nach Fall.