# Google Pay So nehmen Sie Zahlungen per Google Pay an. Informationen zu Transaktionsgebühren für Zahlungsmethoden finden Sie unter [Preisdetails](https://stripe.com/pricing/local-payment-methods). Google Pay ermöglicht es Kund/innen, Zahlungen in Ihrer App oder auf Ihrer Website mit jeder im Google-Konto (z. B. für Google Play, YouTube, Chrome oder ein Android-Gerät) gespeicherten Kredit- oder Debitkarte vorzunehmen. Verwenden Sie die Google Pay API, um eine beliebige im Google-Konto Ihres/Ihrer Kund/in gespeicherte Kredit- oder Debitkarte anzufordern. Google Pay ist vollständig kompatibel mit den Produkten und Funktionen von Stripe (z. B. wiederkehrende Zahlungen), sodass Sie es nach Möglichkeit anstelle eines herkömmlichen Zahlungsformulars verwenden können. So können Sie Zahlungen für physische Waren, Spenden, *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) usw. annehmen. > #### Google Pay-Nutzungsbedingungen > > Durch die Nutzung von Google Pay stimmen Sie den [Nutzungsbedingungen](https://payments.developers.google.com/terms/sellertos) von Google zu. #### Eigenschaften der Zahlungsmethode - **Kundenstandorte** Weltweit, außer Indien - **Transaktionswährung** Siehe [unterstützte Transaktionsährungen](https://docs.stripe.com/currencies.md#presentment-currencies) - **Zahlungsbestätigung** Kundenseitig initiiert - **Art der Zahlungsmethode** Wallet - **Wiederkehrende Zahlungen** Ja - **Auszahlungsintervall** Es gilt das Standard-Auszahlungsintervall - **Connect-Support** Ja - **Unterstützung bei angefochtenen Zahlungen** [Ja](https://docs.stripe.com/google-pay.md#disputed-payments) - **Unterstützung für manuelle Erfassung** Ja - **Komplette/anteilige Rückerstattungen** [Ja/Ja](https://docs.stripe.com/google-pay.md#refunds) #### Geschäftsstandorte Bei Stripe-Konten weltweit (mit Ausnahme von Indien) sind Google Pay-Zahlungen mit Abrechnung in lokaler Währung möglich. #### Produktsupport - Connect - Checkout - Payment Links - Elements - Subscriptions - Invoicing ## Nutzung von Stripe und Google Pay im Vergleich zum Google Play-Abrechnungssystem This guide explains how to configure your app to accept Google Pay for physical goods, services, and other eligible items. Stripe processes these payments, and you pay only Stripe’s [processing fees](https://stripe.com/pricing). For digital products, content, and subscriptions sold in the US or the European Economic Area (EEA), your Android app can accept payments directly in-app through a third-party payment processor such as Stripe. You can use these payment UIs: - [Mobile Payment Element](https://docs.stripe.com/payments/mobile.md) to accept payments directly in-app - [Stripe Checkout](https://docs.stripe.com/mobile/digital-goods/checkout.md) to redirect customers to a Stripe-hosted payment page - [Payment Links](https://docs.stripe.com/mobile/digital-goods/payment-links.md) for a limited number of products and prices Weitere Informationen darüber, für welche Käufe das Abrechnungssystem von Google Play verwendet werden muss, finden Sie in den [Entwicklerbedingungen](https://support.google.com/googleplay/android-developer/answer/10281818) von Google Play. # Android > This is a Android for when platform is android. View the full page at https://docs.stripe.com/google-pay?platform=android. ## Zahlungen per Google Pay in Ihrer Android-App annehmen `GooglePayLauncher`, Teil des Stripe Android-SDK, ist die schnellste und einfachste Art, die Annahme von Zahlungen mit Google Pay in Ihren Android-Apps zu ermöglichen. ## Voraussetzungen Um Google Pay in Android zu unterstützen, benötigen Sie Folgendes: - Eine `minSdkVersion` mit dem Wert `19` oder höher. - Eine `compileSdkVersion` mit dem Wert `28` oder höher. Wenn Sie Tests mit Ihrem eigenen Gerät durchführen möchten, müssen Sie außerdem [Ihrem Google-Konto eine Zahlungsmethode hinzufügen](https://support.google.com/wallet/answer/12058983?visit_id=637947092743186187-653786796&rd=1). ## Integration einrichten In diesem Leitfaden wird davon ausgegangen, dass Sie die neueste Version des Stripe Android SDK verwenden. #### Groovy ```groovy dependencies { implementation 'com.stripe:stripe-android:23.2.0' } ``` Um Google Pay zu verwenden, aktivieren Sie zuerst die Google Pay API, indem Sie dem Tag `` Ihrer Datei **AndroidManifest.xml** Folgendes hinzufügen: ```xml ... ``` Weitere Informationen finden Sie in der [Google Pay API](https://developers.google.com/pay/api/android/guides/setup) für Android. ## Erstellen Sie ein PaymentIntent ### Serverseitig Erstellen Sie eine `PaymentIntent` auf Ihrem Server mit einem [Betrag](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) und einer [Währung](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Entscheiden Sie immer serverseitig, welchen Betrag Sie berechnen, also in einer im Gegensatz zur Client-Seite vertrauenswürdigen Umgebung. So können böswillige Kundinnen und Kunden keine eigenen Preise festlegen. #### Curl ```bash curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -d "amount"=1099 \ -d "currency"="usd" ``` ### Clientseitig Ein PaymentIntent enthält ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Sie können das Client-Geheimnis in Ihrer Android-App verwenden, um den Bezahlvorgang sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie in Ihrer App einen PaymentIntent von Ihrem Server an und speichern Sie dessen Client-Geheimnis. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // ... startCheckout() } private fun startCheckout() { // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret // Click View full sample to see a complete implementation } } ``` ## Google Pay-Schaltfläche hinzufügen Fügen Sie die Google Pay-Schaltfläche zu Ihrer App hinzu, indem Sie dem [Google-Tutorial](https://developers.google.com/pay/api/android/guides/tutorial#add-button) folgen. Dadurch wird sichergestellt, dass Sie die richtigen Ressourcen verwenden. ## GooglePayLauncher instanziieren Erstellen Sie als Nächstes eine Instanz von [GooglePayLauncher](https://github.com/stripe/stripe-android/blob/master/payments-core/src/main/java/com/stripe/android/googlepaylauncher/GooglePayLauncher.kt) in Ihrer `Activity` oder Ihrem `Fragment`. Dies muss in `Activity#onCreate()` erfolgen. `GooglePayLauncher.Config` stellt sowohl erforderliche als auch optionale Eigenschaften bereit, die den `GooglePayLauncher` konfigurieren. Weitere Informationen zu den Konfigurationsoptionen finden Sie unter `GooglePayLauncher.Config`. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // fetch client_secret from backend private lateinit var clientSecret: String private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.checkout_activity) PaymentConfiguration.init(this, PUBLISHABLE_KEY) googlePayButton = /* TODO: Initialize button by following Google's guide. */ val googlePayLauncher = GooglePayLauncher( activity = this, config = GooglePayLauncher.Config( environment = GooglePayEnvironment.Test, merchantCountryCode = "US", merchantName = "Widget Store" ), readyCallback = ::onGooglePayReady, resultCallback = ::onGooglePayResult ) googlePayButton.setOnClickListener { // launch `GooglePayLauncher` to confirm a Payment Intent googlePayLauncher.presentForPaymentIntent(clientSecret) } } private fun onGooglePayReady(isReady: Boolean) { // implemented below } private fun onGooglePayResult(result: GooglePayLauncher.Result) { // implemented below } } ``` Nach Instanziierung des `GooglePayLauncher` wird die `GooglePayLauncher.ReadyCallback`-Instanz aufgerufen und eine Kennung gibt an, ob Google Pay verfügbar und einsatzbereit ist. Diese Kennung kann verwendet werden, um Ihre Benutzeroberfläche zu aktualisieren und Ihrem Kunden/Ihrer Kundin zu signalisieren, dass Google Pay verwendet werden kann. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // continued from above private lateinit var googlePayButton: PayButton private fun onGooglePayReady(isReady: Boolean) { googlePayButton.isEnabled = isReady } } ``` ## GooglePayLauncher starten Sobald Google Pay verfügbar ist und Ihre Anwendung ein `PaymentIntent`- oder `SetupIntent`-Client-Geheimnis erhalten hat, starten Sie `GooglePayLauncher` unter Verwendung der entsprechenden Methode. Verwenden Sie beim Bestätigen eines `PaymentIntent` `GooglePayLauncher#presentForPaymentIntent(clientSecret)`. Beim Bestätigen eines `SetupIntent` verwenden Sie wiederum `GooglePayLauncher#presentForSetupIntent(clientSecret)`. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // fetch client_secret from backend private lateinit var clientSecret: String private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // instantiate `googlePayLauncher` googlePayButton.setOnClickListener { // launch `GooglePayLauncher` to confirm a Payment Intent googlePayLauncher.presentForPaymentIntent(clientSecret) } } } ``` ## Ergebnis verarbeiten Implementieren Sie zum Schluss `GooglePayLauncher.ResultCallback`, um das Ergebnis des `GooglePayLauncher`-Vorgangs zu verarbeiten. Als Ergebnis kommt `GooglePayLauncher.Result.Completed`, `GooglePayLauncher.Result.Canceled` oder `GooglePayLauncher.Result.Failed` infrage. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { // continued from above private fun onGooglePayResult(result: GooglePayLauncher.Result) { when (result) { GooglePayLauncher.Result.Completed -> { // Payment succeeded, show a receipt view } GooglePayLauncher.Result.Canceled -> { // User canceled the operation } is GooglePayLauncher.Result.Failed -> { // Operation failed; inspect `result.error` for the exception } } } } ``` ## Mit Google Pay live gehen Befolgen Sie die [Anweisungen von Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access), um den Produktionszugriff für Ihre App anzufordern. Wählen Sie den Integrationstyp **Gateway**, wenn Sie dazu aufgefordert werden, und stellen Sie Screenshots Ihrer App zur Überprüfung bereit. Nachdem Ihre App genehmigt wurde, testen Sie Ihre Integration in der Produktion, indem Sie die Umgebung auf `GooglePayEnvironment.Production` festlegen und Google Pay über einen signierten Release-Build Ihrer App starten. Denken Sie daran, Ihre [API-Schlüssel](https://docs.stripe.com/keys.md) im *Live-Modus* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments) zu verwenden. Sie können eine `PaymentIntent` mit [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) verwenden, um eine Transaktion zu verarbeiten, ohne die Zahlung zu erfassen. ### Google Pay testen Google bietet Ihnen die Möglichkeit, Zahlungen über seine [Testkartensuite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite) zu testen. Sie können Stripe-[Testkarten](https://docs.stripe.com/testing.md) mit der Testsuite verwenden. In einem Land, in dem Google Pay unterstützt wird, müssen Sie Google Pay mit einem physischen Android-Gerät anstelle eines simulierten Geräts testen. Melden Sie sich mit einer echten in Google Wallet gespeicherten Karte bei einem Google-Konto auf Ihrem Testgerät an. ## PaymentMethod erstellen Wenn Sie Ihre Zahlung auf Ihrem Server bestätigen, können Sie `GooglePayPaymentMethodLauncher` verwenden, um lediglich eine `PaymentMethod` zu erfassen, statt die Zahlung zu bestätigen. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.checkout_activity) PaymentConfiguration.init(this, PUBLISHABLE_KEY) googlePayButton = /* TODO: Initialize button by following Google's guide. */ val googlePayLauncher = GooglePayPaymentMethodLauncher( activity = this, config = GooglePayPaymentMethodLauncher.Config( environment = GooglePayEnvironment.Test, merchantCountryCode = "FR", merchantName = "Widget Store" ), readyCallback = ::onGooglePayReady, resultCallback = ::onGooglePayResult ) googlePayButton.setOnClickListener { googlePayLauncher.present( currencyCode = "EUR", amount = 2500 ) } } private fun onGooglePayReady(isReady: Boolean) { googlePayButton.isEnabled = isReady } private fun onGooglePayResult( result: GooglePayPaymentMethodLauncher.Result ) { when (result) { is GooglePayPaymentMethodLauncher.Result.Completed -> { // Payment details successfully captured. // Send the paymentMethodId to your server to finalize payment. val paymentMethodId = result.paymentMethod.id } GooglePayPaymentMethodLauncher.Result.Canceled -> { // User canceled the operation } is GooglePayPaymentMethodLauncher.Result.Failed -> { // Operation failed; inspect `result.error` for the exception } } } } ``` # React Native > This is a React Native for when platform is react-native. View the full page at https://docs.stripe.com/google-pay?platform=react-native. Das React Native SDK von Stripe ist der schnellste und einfachste Weg, um Google Pay in Ihren React Native-Apps zu akzeptieren. Die Komponente [PlatformPayButton](https://stripe.dev/stripe-react-native/api-reference/index.html#PlatformPayButton) umschließt die erforderliche Nutzeroberfläche von Google, und Sie können die Methoden `confirmPlatformPayPayment` und `createPlatformPayPaymentMethod` verwenden, um nahtlos Zahlungen in Ihrer App mit minimaler Konfiguration zu erfassen oder zu erstellen. > Wenn Sie React Native und Expo verwenden, wird Google Pay von Expo Go nicht unterstützt. Um Google Pay mit Expo zu verwenden, müssen Sie einen [Entwicklungs-Build](https://docs.expo.dev/get-started/set-up-your-environment/?mode=development-build&platform=android) erstellen. Wenn Sie bereits ein Expo Go-Projekt haben, können Sie es [zu einem Entwicklungs-Build migrieren](https://docs.expo.dev/develop/development-builds/expo-go-to-dev-build/). ## 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. ## Google Pay aktivieren Um Google Pay zu verwenden, aktivieren Sie zuerst die Google Pay API, indem Sie dem Tag `` Ihrer Datei **AndroidManifest.xml** Folgendes hinzufügen: ```xml ... ``` Weitere Informationen finden Sie in der [Google Pay API](https://developers.google.com/pay/api/android/guides/setup) für Android. ## Erstellen Sie ein PaymentIntent [Serverseitig] Erstellen Sie zunächst einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung an. Wenn Sie bereits eine Integration mit der [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) haben, fügen Sie `card` zur Liste der [Zahlungsmethoden-Typen](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren `PaymentIntent` hinzu (dies ist auch die Standardzahlungsmethode wenn keine angegeben wird): ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=card" \ -d amount=1099 \ -d currency=usd ``` Ein PaymentIntent enthält ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Sie können das Client-Geheimnis in Ihrer React Native-App verwenden, um den Zahlungsvorgang sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zurückzugeben. Fordern Sie in Ihrer App einen PaymentIntent von Ihrem Server an und speichern Sie dessen Client-Geheimnis. ## Google Pay initialisieren [Clientseitig] Prüfen Sie zunächst, ob das Gerät Google Pay unterstützt, indem Sie `isPlatformPaySupported` aufrufen. ```javascript import { usePlatformPay } from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported } = usePlatformPay(); React.useEffect(() => { (async function () { if (!(await isPlatformPaySupported({ googlePay: {testEnv: true} }))) { Alert.alert('Google Pay is not supported.'); return; } })(); }, []); ... return ( ... ); } ``` ## Google Pay-Formular anzeigen [Clientseitig] Wenn Sie wissen, dass Google Pay verfügbar ist und Ihre App ein Client-Geheimnis für `PaymentIntent` oder `SetupIntent` erhalten hat, rufen Sie `confirmPlatformPayPayment` auf. Wenn Sie einen `SetupIntent` bestätigen, verwenden Sie stattdessen `confirmPlatformPaySetupIntent`. ```javascript import {PlatformPayButton, usePlatformPay} from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported, confirmPlatformPayPayment, } = usePlatformPay(); React.useEffect(() => { ... // see above }, []); const fetchPaymentIntentClientSecret = async () => { // Fetch payment intent created on the server, see above const response = await fetch(`${API_URL}/create-payment-intent`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ currency: 'usd', }), }); const { clientSecret } = await response.json(); return clientSecret; }; const pay = async () => { const clientSecret = await fetchPaymentIntentClientSecret(); const { error, paymentIntent } = await confirmPlatformPayPayment( clientSecret, { googlePay: { testEnv: true, merchantName: 'My merchant name', merchantCountryCode: 'US', currencyCode: 'USD', billingAddressConfig: { format: PlatformPay.BillingAddressFormat.Full, isPhoneNumberRequired: true, isRequired: true, }, }, } ); if (error) { Alert.alert(error.code, error.message); // Update UI to prompt user to retry payment (and possibly another payment method) return; } Alert.alert('Success', 'The payment was confirmed successfully.'); console.log(JSON.stringify(paymentIntent, null, 2)); }; return ( ); } ``` ## Optional: PaymentMethod erstellen [Clientseitig] Wenn Sie Ihre Zahlung auf Ihrem Server bestätigen, können Sie Google Pay verwenden, um nur eine `PaymentMethod` zu erfassen, anstatt eine Zahlung zu bestätigen. Verwenden Sie die Methode `createPlatformPayPaymentMethod`, um diesen Aufruf durchzuführen: ```javascript import {PlatformPayButton, usePlatformPay} from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported, createPlatformPayPaymentMethod, } = usePlatformPay(); React.useEffect(() => { ... // see above }, []); const createPaymentMethod = async () => { const { error, paymentMethod } = await createPlatformPayPaymentMethod({ googlePay: { amount: 12, currencyCode: 'USD', testEnv: true, merchantName: 'Test', merchantCountryCode: 'US', }, }); if (error) { Alert.alert(error.code, error.message); return; } else if (paymentMethod) { Alert.alert( 'Success', `The payment method was created successfully. paymentMethodId: ${paymentMethod.id}` ); } }; return ( ); } ``` ## Mit Google Pay live gehen Befolgen Sie die [Anweisungen von Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access), um den Produktionszugriff für Ihre App anzufordern. Wählen Sie den Integrationstyp **Gateway**, wenn Sie dazu aufgefordert werden, und stellen Sie Screenshots Ihrer App zur Überprüfung bereit. Nachdem Ihre App genehmigt wurde, testen Sie Ihre Integration in der Produktion, indem Sie `testEnv: false` verwenden und Google Pay über einen signierten Release-Build Ihrer App starten. Denken Sie daran, Ihre [API-Schlüssel](https://docs.stripe.com/keys.md) im *Live-Modus* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments) zu verwenden. Sie können eine `PaymentIntent` mit [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) verwenden, um eine Transaktion zu verarbeiten, ohne die Zahlung zu erfassen. ### Google Pay testen Google bietet Ihnen die Möglichkeit, Zahlungen über seine [Testkartensuite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite) zu testen. Sie können Stripe-[Testkarten](https://docs.stripe.com/testing.md) mit der Testsuite verwenden. In einem Land, in dem Google Pay unterstützt wird, müssen Sie Google Pay mit einem physischen Android-Gerät anstelle eines simulierten Geräts testen. Melden Sie sich mit einer echten in Google Wallet gespeicherten Karte bei einem Google-Konto auf Ihrem Testgerät an. # Internet > This is a Internet for when platform is web. View the full page at https://docs.stripe.com/google-pay?platform=web. ## Google Pay on the Web akzeptieren Zahlungen per Google Pay können Sie im Web über [Checkout](https://docs.stripe.com/payments/checkout.md) oder [Elements](https://docs.stripe.com/payments/elements.md) akzeptieren, indem Sie Google Pay in Ihren [Zahlungsmethodeneinstellungen](https://dashboard.stripe.com/settings/payment_methods) aktivieren. Es ist keine zusätzliche Codeimplementierung erforderlich, um Google Pay in Checkout zu verwenden. Für Elements erfahren Sie in unseren Leitfäden zu den Themen [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element.md) oder [Eine Zahlung akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout), wie Sie Google Pay zu Ihrer Website hinzufügen können. Sie müssen von einer HTTPS-Webseite aus ein durch eine TLS-Domain validiertes Zertifikat angeben, um Google Pay-Zahlungen im Web annehmen zu können. ### Registrieren Sie Ihre Domain mit Google Pay Um Google Pay nutzen zu können, müssen Sie alle Ihre Webdomains registrieren, die eine Google Pay-Schaltfläche aufweisen. Dazu gehören Top-Level-Domains (z. B. **stripe.com**) und Subdomains (z. B. **shop.stripe.com**), in der Produktion und zu Testzwecken. > #### Subdomains > > `www` ist eine Subdomain (zum Beispiel **www.stripe.com**), die Sie ebenfalls registrieren müssen. ```curl curl https://api.stripe.com/v1/payment_method_domains \ -u "<>:" \ -d "domain_name=example.com" ``` Wenn Sie [Direct Charges](https://docs.stripe.com/connect/direct-charges.md) mit *Connect* (Connect is Stripe's solution for multi-party businesses, such as marketplace or software platforms, to route payments between sellers, customers, and other recipients) verwenden, müssen Sie die Domain für jedes verbundene Konto über die API konfigurieren. Diese Voraussetzung gilt nicht für verbundene Konten, die andere Gebührenarten verwenden. Nach der Registrierung Ihrer Domains können Sie mit Ihren Live-API-Schlüsseln Zahlungen auf Ihrer Website abwickeln. ## Google Pay testen Google bietet Ihnen die Möglichkeit, Zahlungen über seine [Testkartensuite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite) zu testen. Sie können Stripe [Testkarten](https://docs.stripe.com/testing.md) mit der Testsuite verwenden. Bevor Sie eine Stripe-Testkarte verwenden können, müssen Sie eine echte Karte zu Ihrer Wallet hinzufügen, damit Google Pay angezeigt wird. Wenn Sie die Geräte- und Integrationsanforderungen nicht erfüllen, zeigt Stripe Google Pay nicht als Zahlungsoption an. Um Rendering-Probleme mit Google Pay zu beheben, verwenden Sie unsere [Testseite](https://docs.stripe.com/testing/wallets.md). ## Zahlungsanfechtungen Nutzer/innen müssen Zahlungen über ihre Google Pay-Konten authentifizieren, um das Risiko von Betrug oder nicht zugeordneten Zahlungen zu verringern. Nutzer/innen können Transaktionen jedoch weiterhin anfechten, nachdem sie die Zahlung abgeschlossen haben. Sie können Nachweise einreichen, um einer Zahlungsanfechtung direkt zu widersprechen. Die Zahlungsanfechtung ist identisch mit der bei Kartenzahlungen. Erfahren Sie, wie Sie mit [Anfechtungen umgehen](https://docs.stripe.com/disputes/responding.md). ### Haftungsverlagerung für Google Pay-Zahlungen Google Pay unterstützt die [Haftungsverlagerung](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#disputed-payments) weltweit. Dies gilt automatisch für Nutzer/innen von bei Stripe gehosteten Produkten und bei Verwendung von Stripe.js. Für Visa-Transaktionen außerhalb eines von Stripe gehosteten Produkts müssen Sie die Haftungsverlagerung in der Google Pay & Wallet-Konsole aktivieren. Gehen Sie dazu zu Ihrer ***Google Pay & Wallet Console***, wählen Sie ***Google Pay API*** in der Navigationsleiste auf der linken Seite und aktivieren Sie dann ***Fraud Liability Protection for Visa Device Tokens*** zum Schutz vor Haftungsverlagerung. Es gibt drei Anwendungsfälle von Google Pay-Transaktionen: 1. Wenn Nutzer/innen über ihr Mobilgerät eine Karte zur Google Pay-App hinzufügen, wird diese als Device Primary Account Number (DPAN, Hauptkontonummer des Geräts) gespeichert und die Haftungsverlagerung wird standardmäßig unterstützt. 1. Wenn der/die Nutzer/in eine Karte zu Chrome oder einer Google-Anwendung (z. B. YouTube oder Play) hinzufügt, wird diese als Funding Primary Account Number (FPAN) gespeichert. Wenn Sie [3D Secure](https://docs.stripe.com/payments/3d-secure.md) verwenden, unterstützen wir die Haftungsumkehr weltweit für alle großen Netzwerke, einschließlich Visa. Sie können die [Stripe Radar-Regeln](https://docs.stripe.com/radar/rules.md#request-3d-secure) anpassen, um die Aktivierung von 3D Secure anzufordern. 1. Wenn der/die Nutzer/in Google Pay als Zahlungsmethode auf einer E-Commerce-Website oder in einer App auswählt, die mit Google Pay bezahlt, werden die Karten als E-Commerce-Token gespeichert, die die hinterlegten Karten darstellen. Weder die Haftungsverschiebung noch 3D Secure werden derzeit für E-Commerce-Token unterstützt. Für Sigma-Nutzer/innen enthält die Tabelle `charges` das Feld `card_token_type`, das den Typ der Google Pay-Transaktion angibt. Eine FPAN-Transaktion legt den `card_token_type` auf `fpan` fest. DPAN- und E-Commerce-Token-Transaktionen legen den `card_token_type` auf `dpan_or_ecommerce_token` fest. ## Rückerstattungen Sie können jede erfolgreiche Google Pay-Zahlung teilweise oder vollständig zurückerstatten. Das Rückerstattungsverfahren läuft genau wie bei Kartenzahlungen ab. Anweisungen zum Initiieren oder Verwalten von Rückerstattungen finden Sie unter [Zahlungen zurückerstatten und abbrechen](https://docs.stripe.com/refunds.md).