--- title: "Google Pay" description: "Google Pay è il sistema di pagamento digitale di Google che consente pagamenti rapidi e sicuri tramite smartphone o browser. In questa guida scoprirai come attivarlo, configurarlo su Fabrick Payment Orchestra e integrarlo correttamente nel tuo e-commerce." url: "https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/" language: "it" --- # Google Pay ## Perché scegliere Google Pay Google Pay è il **sistema di pagamento digitale sviluppato da Google** che permette di effettuare pagamenti in modo semplice, veloce e sicuro tramite smartphone (NFC) o sul web, utilizzando i dati della carta salvati nel proprio account Google. Integrarlo nell'ecommerce amplia le modalità di pagamento disponibili e migliora l'esperienza utente grazie a un checkout rapido e senza frizioni. Elimina la necessità di inserire manualmente i dati della carta e, grazie all'autenticazione già presente sul dispositivo o sull'account Google, i clienti autorizzano i pagamenti in modo immediato con un semplice tap. > **Approfondimento** > > Per ulteriori informazioni consulta la [documentazione ufficiale Google Pay API](https://developers.google.com/pay/api) --- ## Servizi e funzionalità disponibili tramite integrazione Fabrick L'integrazione di Google Pay con Fabrick Payment Orchestra mette a disposizione un ecosistema completo di funzionalità per semplificare la gestione delle transazioni e migliorare l'esperienza sia per il venditore che per il cliente. - **Compatibile con app e siti web**: supporto sia per app Android che per integrazioni web tramite [Google Pay JS API](https://developers.google.com/pay/api/web/guides/tutorial). - **Gestione Payment Token**: Fabrick gestisce autonomamente il token di pagamento presentando Google Pay sulla propria pagina, senza sviluppi aggiuntivi lato merchant. - **Tokenizzazione**: il metodo di pagamento può essere tokenizzato per riutilizzarlo negli addebiti successivi (vedi [Tokenizzazione](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#tokenizzazione)). - **Pagamenti ricorrenti**: Google Pay può essere utilizzato come metodo di pagamento di una serie ricorrente (vedi [Pagamenti ricorrenti](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#pagamenti-ricorrenti)). - **Fabrick Guaranteed Payments**: servizio di prevenzione frodi a supporto dell'esercente ([scopri di più](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/fraud-prevention/fabrick-guaranteed-payments/)). - **Fabrick Advice**: servizio di Transaction Risk Analysis (TRA) per usufruire delle esenzioni previste dalla PSD2 ([scopri di più](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/fraud-prevention/fabrick-advice/)). - **Riconciliazione semplificata**: gestione dei pagamenti tramite report dedicati ([scopri di più](https://www.fabrick.com/it-it/assistenza/fabrick-dashboard/)). - **Gestione avanzata delle transazioni**: supporto a catture e storni parziali o multipli per una gestione flessibile dei pagamenti. - **Supporto multivaluta**: compatibilità con diverse valute per transazioni internazionali. - **Supporto circuiti internazionali**: Google Pay tramite Fabrick supporta Visa e Mastercard. --- ## Google Pay su Fabrick Payment Orchestra: attivazione e modalità di integrazione ### Richiesta di attivazione Per iniziare ad accettare pagamenti con Google Pay, puoi richiedere l'attivazione: - Contattando il tuo referente commerciale - Contattando l'assistenza al seguente [link](https://landing.fabrick.com/fabrick-dashboard-support) > **Dati richiesti per l'attivazione** > > Per l'integrazione tramite **Web Component** è necessario comunicare il **Merchant ID** dell'account Google Pay & Wallet Console, da associare all'account Fabrick per l'ambiente in uso (vedi [Configurazione aggiuntiva per Web Component e WebView](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#configurazione-aggiuntiva-per-web-component-e-webview)). Una volta completate le procedure necessarie: - Fabrick abilita Google Pay sul negozio e informa l'esercente. - È possibile verificare l'attivazione del metodo di pagamento all'interno della Dashboard, al percorso **Workspace → Negozi → \[Seleziona negozio] → Configurazioni** ![Attivazione di Google Pay in Dashboard](https://docs.fabrick.com/assets/images/gpay-confirm-activation-01-1216949a333513d175aeca22049296a6.png) > **Attivazione completata** > > Da questo momento, il tuo e-commerce è pronto per accettare pagamenti Google Pay tramite Fabrick Payment Orchestra. ### Tipologie di integrazione Fabrick offre due modalità di integrazione per utilizzare Google Pay: - **Integrazione hosted** ### Integrazioni supportate ✓ — Checkout Page ✓ — Pay By Link ✓ — Web Component ✓ — Lightbox Google Pay viene mostrato direttamente nella pagina di pagamento. Fabrick gestisce autonomamente la visualizzazione del pulsante, la generazione del token e l'intera fase di processamento della richiesta di pagamento. Per le integrazioni tramite **Web Component** o che utilizzano la **WebView** è richiesto un [ulteriore passaggio di configurazione](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#configurazione-aggiuntiva-per-web-component-e-webview). - **Integrazione tramite API** ### Integrazioni supportate ✓ — API Only In questa modalità Google Pay viene integrato direttamente sul sito o sull'app dell'esercente. Il merchant si occupa dell'implementazione del pulsante di pagamento, della generazione del token e del relativo invio a Fabrick per l'elaborazione della transazione. > **Compatibilità browser** > > Google Pay è supportato dai principali browser moderni, tra cui Chrome, Edge, Firefox e Safari. > **Testare Google Pay in ambiente sandbox** > > Per effettuare i test è necessario un account Google e un dispositivo Android o un browser che supporta Google Wallet. > > Per approfondire: > > - [Come testare entrambi i metodi di autenticazione](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#test-metodi-autenticazione) > - [Simulare il flusso 3DS in sandbox](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#test-3ds-sandbox) --- ## Integrazione hosted **Google Pay viene mostrato direttamente nella pagina di pagamento**. Fabrick gestisce autonomamente il pulsante, la generazione del token di pagamento e l'eventuale flusso di autenticazione (SCA). ![Google Pay nella pagina di pagamento Fabrick](https://docs.fabrick.com/assets/images/gpay-checkout-page-01-fb54f57de2c9883d3ee17abb61352f6e.png) Quando l'utente seleziona Google Pay, viene aperta nel browser la modale di Google per scegliere la carta con cui completare il pagamento. ![Modale Google per la scelta della carta](https://docs.fabrick.com/assets/images/gpay-checkout-page-02-a443a082b55a6e624d2cdbcb4ba14243.png) ### Configurazione aggiuntiva per Web Component e WebView Per queste integrazioni, Google Pay viene eseguito direttamente sul dominio dell'esercente. È richiesto, quindi, di registrare il proprio dominio tramite la Google Pay & Wallet Console e attendere l'approvazione da parte di Google. Durante la registrazione, quando richiesto, seleziona **PSP: Axerve** come tipo di integrazione. La procedura è descritta nella [guida ufficiale](https://developers.google.com/pay/api/web/guides/test-and-deploy/publish-your-integration). In ambiente sandbox l'approvazione del dominio non è richiesta. > **Attivazione completata** > > Per le integrazioni tramite **Web Component**, comunica il tuo **Merchant ID** al referente commerciale o all'[assistenza](https://landing.fabrick.com/fabrick-dashboard-support) per associarlo all'account Fabrick e completare la configurazione. In produzione, comunicalo dopo aver ricevuto l'approvazione da parte di Google. > **Utilizzo in Android WebView** > > Se il tuo checkout web è integrato in una WebView Android, sono richieste configurazioni aggiuntive lato app, per questa integrazione non è necessario comunicare a Fabrick il tuo **Merchant ID**. Consulta la [guida ufficiale Google](https://developers.google.com/pay/api/android/guides/recipes/using-android-webview). --- ## Integrazione tramite API ### Requisiti per l'attivazione Per utilizzare l'integrazione tramite API con Google Pay sono necessari: - **Google Pay & Wallet Console**: È necessario registrare un account sulla [Google Pay & Wallet Console](https://pay.google.com/business/console) per gestire l'integrazione, accettare le policy e ottenere il `merchantId` da utilizzare in produzione. - **Accettazione delle policy Google**: Tutti gli esercenti devono accettare la [Google Pay API Terms of Service](https://payments.developers.google.com/terms/sellertos) e la [Google Pay APIs Acceptable Use Policy](https://payments.developers.google.com/terms/aup) prima di procedere con l'integrazione. - **Registrazione del dominio e accesso in produzione**: Prima di andare in produzione è necessario registrare il proprio dominio tramite la Google Pay & Wallet Console e attendere l'approvazione da parte di Google. La procedura è descritta nella [guida ufficiale](https://developers.google.com/pay/api/web/guides/test-and-deploy/publish-your-integration). In ambiente sandbox l'approvazione del dominio non è richiesta. > **Attivazione completata** > > Dopo aver ricevuto l'approvazione da parte di Google, comunica il tuo **Merchant ID** al referente commerciale o all'[assistenza](https://landing.fabrick.com/fabrick-dashboard-support) per associarlo all'account Fabrick e completare la configurazione. > **Google Pay è un trademark di Google LLC.** --- ### Configurazione del codice JavaScript sul sito L'integrazione diretta web avviene seguendo la [guida ufficiale Google Pay](https://developers.google.com/pay/api/web/guides/tutorial), con alcune impostazioni specifiche per Fabrick descritte nei passi seguenti. #### Passo 1 — Configurazione `tokenizationSpecification` Impostare `gateway` su `gestpay` per indicare a Google Pay di utilizzare Fabrick come gateway di pagamento. Nel parametro `gatewayMerchantId` specificare lo **shopLogin Fabrick** relativo all'ambiente in uso (sandbox o produzione): ```json "tokenizationSpecification": { "type": "PAYMENT_GATEWAY", "parameters": { "gateway": "gestpay", "gatewayMerchantId": "GESPAY12345" } } ``` > [Passaggio 2 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#tokenization) --- #### Passo 2 — Reti e metodi di pagamento supportati Configurare le reti e i metodi di autenticazione supportati da Fabrick tramite i parametri `allowedCardNetworks`, che definisce i circuiti accettati, e `allowedCardAuthMethods`, che definisce la modalità di autenticazione. Fabrick supporta entrambe le modalità: - **`PAN_ONLY`** — la carta è memorizzata nell'Account Google dell'utente, non sul dispositivo. Google restituisce il PAN con mese e anno di scadenza. La transazione **[non soddisfa nativamente la SCA](https://developers.google.com/pay/api/android/guides/resources/sca)**: Fabrick eseguirà automaticamente il flusso 3DS come fallback. - **`CRYPTOGRAM_3DS`** — la carta è tokenizzata sul dispositivo Android tramite Google Wallet. Google restituisce un criptogramma 3DS generato direttamente sul dispositivo, che **soddisfa nativamente i requisiti SCA**: non sarà necessario gestire il flusso 3DS. > **CRYPTOGRAM_3DS è disponibile solo su Android** > > I token `CRYPTOGRAM_3DS` (DPAN) sono generati esclusivamente su dispositivi Android. Da desktop e da dispositivi iOS Google Pay restituisce sempre token `PAN_ONLY` ([FAQ ufficiale Google](https://developers.google.com/pay/api/web/support/faq)). ```javascript const allowedCardNetworks = ["MASTERCARD", "VISA"]; const allowedCardAuthMethods = ["PAN_ONLY", "CRYPTOGRAM_3DS"]; ``` > [Passaggio 3 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#supported-card-networks) > **Approfondimento** > > Per ulteriori dettagli sui parametri di configurazione consulta la [documentazione ufficiale Google](https://developers.google.com/pay/api/android/reference/request-objects?hl=it#CardParameters). > **Come testare entrambi i metodi di autenticazione** > > I due metodi richiedono carte diverse in ambiente di test: > > - **`PAN_ONLY`** — utilizza una carta associata al tuo account Google per i pagamenti online. Sono le carte che vengono mostrate nella finestra di checkout Google Pay da browser. Puoi aggiungerne una direttamente da Chrome: *Impostazioni → Compilazione automatica e password → Metodi di pagamento → Aggiungi carta di credito*. > - **`CRYPTOGRAM_3DS`** — utilizza una carta tokenizzata su dispositivo Android tramite Google Wallet. Non vengono mostrate nel checkout web: per testarle è necessario effettuare il pagamento da smartphone. > > > **Nota**: le carte presenti su [payments.google.com](https://payments.google.com/) sono distinte da quelle abilitate per il checkout web e non vengono mostrate nella finestra di pagamento Google Pay da browser. --- #### Passo 3 — Impostazione ambiente Google Pay Il parametro `environment` determina in quale ambiente opera Google Pay. Impostare **`TEST`** o **`PRODUCTION`** in base all'ambiente in uso: ```javascript const paymentsClient = new google.payments.api.PaymentsClient({ environment: 'TEST' }); // Per l'ambiente di produzione utilizzare: { environment: 'PRODUCTION' } ``` > [Passaggio 5 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#js-load) > **Ambiente sandbox** > > In ambiente **TEST** il `gatewayMerchantId` deve essere valorizzato con lo **shopLogin sandbox** Fabrick, non con quello di produzione. Il valore va inserito nel [Passo 1](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#passo-1--configurazione-tokenizationspecification). > > > Nota: passare all'ambiente **PRODUCTION** solo dopo aver completato tutti i test e aver ricevuto le approvazioni da **Google**. --- #### Passo 4 — Aggiunta del pulsante Google Pay Aggiungere il pulsante Google Pay alla pagina di checkout rispettando le [linee guida di brand Google](https://developers.google.com/pay/api/android/guides/brand-guidelines) e le opzioni di [personalizzazione disponibili](https://developers.google.com/pay/api/web/guides/resources/customize): ```javascript function addGooglePayButton() { const paymentsClient = getGooglePaymentsClient(); const button = paymentsClient.createButton({ onClick: onGooglePaymentButtonClicked, allowedPaymentMethods: [baseCardPaymentMethod] }); document.getElementById('container').appendChild(button); } ``` > [Passaggio 7 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#add-button) --- #### Passo 5 — Definizione dei dati di pagamento richiesti Comporre l'oggetto `paymentDataRequest` con importo, valuta e `merchantInfo`: ```javascript const paymentDataRequest = Object.assign({}, baseRequest); paymentDataRequest.allowedPaymentMethods = [cardPaymentMethod]; paymentDataRequest.transactionInfo = { totalPriceStatus: 'FINAL', totalPrice: '100.00', currencyCode: 'EUR', countryCode: 'IT' }; paymentDataRequest.merchantInfo = { merchantId: 'MERCHANT_ID_GOOGLE', merchantName: 'Nome del tuo negozio' }; ``` > [Passaggio 8 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#paymentdatarequest) > **merchantId: quando è necessario?** > > `merchantId` identifica il tuo account sulla [Google Pay & Wallet Console](https://pay.google.com/business/console) ed è **obbligatorio in produzione**. In ambiente `TEST` può essere omesso o valorizzato con un placeholder. Per ottenerlo è necessario completare la registrazione sulla console Google, come descritto nella [guida ufficiale](https://developers.google.com/pay/api/web/guides/test-and-deploy/publish-your-integration). --- #### Passo 6 — Gestione del click e recupero del token di pagamento Al click sul pulsante, avviare la richiesta e recuperare il token da inviare a Fabrick: ```javascript function onGooglePaymentButtonClicked() { const paymentDataRequest = getGooglePaymentDataRequest(); const paymentsClient = getGooglePaymentsClient(); paymentsClient.loadPaymentData(paymentDataRequest) .then(function(paymentData) { // Inviare il token di pagamento a Fabrick tramite payment/submit processPayment(paymentData.paymentMethodData.tokenizationData.token); }) .catch(function(err) { console.error(err); }); } ``` > [Passaggio 9 della guida ufficiale Google](https://developers.google.com/pay/api/web/guides/tutorial?hl=it#event-handler) --- #### Passo 7 — Invio della richiesta di pagamento a Fabrick Una volta ottenuto il token dall'oggetto `paymentData`, il pagamento viene gestito in due step consecutivi: `payment/create` per inizializzare la transazione e `payment/submit` per inviare il token Google Pay. #### Step 1 — Creazione della richiesta di pagamento **Request** ```http POST /api/v1/payment/create Host (sandbox): sandbox.gestpay.net Host (produzione): ecomms2s.sella.it Authorization: apikey **************** Content-Type: application/json ``` ```json { "shopLogin": "GESPAY12345", "amount": "100", "currency": "EUR", "shopTransactionID": "FBK_OrderID" } ``` > **warning** > > I valori di **importo** e **valuta** passati a `payment/create` devono coincidere esattamente con quelli definiti nel [Passo 5](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#passo-5--definizione-dei-dati-di-pagamento-richiesti). > **Simulare il flusso 3DS in sandbox** > > In sandbox il flusso 3DS per token **PAN_ONLY** potrebbe non attivarsi automaticamente. Per simulare il comportamento in produzione aggiungere `exemption: SKIP` nella chiamata `payment/create`: > > ```json > { > "shopLogin": "GESPAY12345", > "amount": "100", > "currency": "EUR", > "shopTransactionID": "FBK_OrderID", > "transDetails": { > "threeDsContainer": { > "exemption": "SKIP" > } > } > } > ``` **Response** ```json { "error": { "code": "0", "description": "request correctly processed" }, "payload": { "paymentToken": "f0419188-8a78-4918-913c-a491e4e78084", "paymentID": "1881129911957", "userRedirect": null, "qrCode": null } } ``` #### Step 2 — Invio del token e processamento Inviare una richiesta a `payment/submit` con il token Google Pay ottenuto al [Passo 6](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#passo-6--gestione-del-click-e-recupero-del-token-di-pagamento): - Header **`PaymentToken`**: valorizzare con il `paymentToken` ricevuto dallo [Step 1](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#step-1--creazione-della-richiesta-di-pagamento) - Body: inserire il token Google Pay in `paymentTypeDetails.googlePay.tokenizationData.token` **Request** ```http POST /api/v1/payment/submit Host (sandbox): sandbox.gestpay.net Host (produzione): ecomms2s.sella.it PaymentToken: f0419188-8a78-4918-913c-a491e4e78084 Content-Type: application/json ``` ```json { "shopLogin": "GESPAY12345", "paymentType": "GOOGLEPAY", "paymentTypeDetails": { "googlePay": { "tokenizationData": { "token": { "signature": "MEYC...", "protocolVersion": "ECv1", "signedMessage": "{\"encryptedMessage\":\"EFVBR...\",\"ephemeralPublicKey\":\"BPiL...\",\"tag\":\"ZN43...\"}" } } } } } ``` La response varia in base al tipo di token Google Pay ricevuto: - **`PAN_ONLY`** — la SCA non è soddisfatta nativamente. Fabrick restituisce il codice `8006` con `userRedirect.href` valorizzato con l'URL della pagina di autenticazione 3DS. Il merchant deve reindirizzare il buyer a quell'URL per completare la verifica. Al termine, il buyer viene rimandato alla pagina di esito e la transazione viene finalizzata. - **`CRYPTOGRAM_3DS`** — la SCA è già soddisfatta dal criptogramma generato sul dispositivo, non è necessario gestire il flusso 3DS. Se la transazione viene approvata, la response restituisce `transactionResult: "OK"` e il pagamento è completato. Contestualmente, il sistema invia una notifica server to server (S2S) con l'esito della transazione. > **Identificare il tipo di token Google Pay** > > Il campo `protocolVersion` (`ECv1` / `ECv2`) indica la **versione del protocollo di cifratura** del token, non il metodo di autenticazione: un token `ECv2` può veicolare sia `PAN_ONLY` che `CRYPTOGRAM_3DS`. Il metodo effettivo (`authMethod`) è contenuto nel `signedMessage` cifrato, leggibile solo dal gateway. > > Per distinguere lato merchant le transazioni che richiedono lo step-up 3DS, imposta `assuranceDetailsRequired: true` nei `CardParameters` ([Passo 2](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#passo-2--reti-e-metodi-di-pagamento-supportati)): la response Google Pay includerà l'oggetto `assuranceDetails` con i campi `accountVerified` e `cardHolderAuthenticated`. Solo se **entrambi** sono `true` la transazione è conforme SCA e non richiede 3DS; in caso contrario Fabrick attiverà il flusso 3DS (codice `8006` con `userRedirect.href`). Per approfondire consulta la [guida SCA ufficiale Google](https://developers.google.com/pay/api/web/guides/resources/sca). **CRYPTOGRAM_3DS — SCA soddisfatta** Esempio di risposta per token che soddisfano nativamente i requisiti SCA: **Response** ```json { "error": { "code": "0", "description": "request correctly processed" }, "payload": { "transactionType": "submit", "transactionResult": "OK", "transactionErrorCode": "0", "transactionErrorDescription": "Transaction correctly processed", "bankTransactionID": "2528", "shopTransactionID": "FBK_OrderID", "shopTransactionID_2": "", "authorizationCode": "284731", "paymentID": "1881129911957", "currency": "EUR", "country": "", "company": "GOOGLEPAY - VISA", "tdLevel": "FULL", "buyer": { "name": "", "email": "" }, "risk": { "riskResponseCode": "", "riskResponseDescription": "" }, "customInfo": {}, "alertCode": "", "alertDescription": "", "cvvPresent": "N", "maskedPAN": "", "paymentMethod": "", "productType": "", "token": "", "tokenExpiryMonth": "", "tokenExpiryYear": "", "userRedirect": { "href": "https://sandbox.gestpay.net/pagam/AxerveThankYou.aspx" } } } ``` **PAN_ONLY — SCA non soddisfatta** Esempio di risposta per token che non soddisfano i requisiti SCA: **Response** ```json { "error": { "code": "0", "description": "request correctly processed" }, "payload": { "transactionType": "submit", "transactionResult": "", "transactionErrorCode": "8006", "transactionErrorDescription": "Verify By Visa", "bankTransactionID": "", "shopTransactionID": "", "shopTransactionID_2": "", "authorizationCode": "", "paymentID": "1881129911957", "currency": "", "country": "", "company": null, "tdLevel": "", "buyer": { "name": "", "email": "" }, "risk": { "riskResponseCode": "", "riskResponseDescription": "" }, "customInfo": {}, "alertCode": "", "alertDescription": "", "cvvPresent": "N", "maskedPAN": "", "paymentMethod": "", "productType": "", "token": "", "tokenExpiryMonth": "", "tokenExpiryYear": "", "userRedirect": { "href": "https://sandbox.gestpay.net/pagam/pagam3d.aspx?a=GESPAY12345&b=f0419188-8a78-4918-913c-a491e4e78084&axerve3D=True&IsLightBox=False" } } } ``` --- ## Funzionalità aggiuntive del metodo di pagamento Puoi abilitare funzionalità aggiuntive sulla transazione modificando la chiamata `payment/create` per includere i servizi specifici, come [Fabrick Guaranteed Payments](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/fraud-prevention/fabrick-guaranteed-payments/) o [Fabrick Advice](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/fraud-prevention/fabrick-advice/). I servizi configurati verranno applicati automaticamente alla transazione quando il buyer seleziona Google Pay. ### Separazione tra autorizzazione e cattura Google Pay è gestito come una carta: la modalità di gestione delle transazioni, **contestuale** o **separata**, è quella configurata per le carte e non richiede un'impostazione dedicata. Per verificare o modificare la configurazione: 1. Accedi alla Dashboard e vai su **Impostazioni → Accedi alle configurazioni** ![Accesso alle configurazioni dalla Dashboard](https://docs.fabrick.com/assets/images/dashboard-access-configurations-f4782eb17db7b8fb6f23649ba8e3e5d7.png) 2. Una volta reindirizzato sul backoffice, vai su **Configurazioni → Ambiente** e clicca su **MOTO**: si apre un pannello laterale con l'elenco dei metodi di pagamento attivi 3. Individua la riga delle **carte** e seleziona la modalità desiderata tra **Contestuale** e **Separata** > **Configurazione condivisa con le carte** > > La modalità impostata per le carte vale per tutti i pagamenti con carta, inclusi quelli effettuati con Google Pay e Apple Pay: modificarla per il wallet significa modificarla anche per le carte. > **MOTO** > > Per approfondire il funzionamento delle due modalità, consulta la sezione [separazione tra autorizzazione e cattura](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/introduction/getting-started/#moto). ### Tokenizzazione Il metodo di pagamento utilizzato con Google Pay può essere **tokenizzato**: Fabrick restituisce un token che rappresenta la carta scelta dal buyer nel proprio wallet e che può essere riutilizzato per gli addebiti successivi, senza chiedere di nuovo i dati di pagamento. La tokenizzazione si richiede nella chiamata `payment/create`, valorizzando il campo `requestToken` con `MASKEDPAN`. > **Token indipendente dal metodo di autenticazione** > > Il token si comporta allo stesso modo con `PAN_ONLY` e con `CRYPTOGRAM_3DS`: il metodo di autenticazione utilizzato durante il pagamento non incide sulla generazione del token né sul suo riutilizzo. **Integrazione hosted** È sufficiente la chiamata `payment/create`: Fabrick gestisce il pulsante Google Pay, la generazione del payload e la restituzione del token. **Request** ```http POST /api/v1/payment/create Host (sandbox): sandbox.gestpay.net Host (produzione): ecomms2s.sella.it Authorization: apikey **************** Content-Type: application/json ``` ```json { "shopLogin": "GESPAY12345", "amount": "100", "currency": "EUR", "shopTransactionID": "FBK_OrderID", "paymentChannel": { "channelType": ["LINK"] }, // Solo per Pay By Link "requestToken": "MASKEDPAN" } ``` > **Limitare la pagina a carta e wallet** > > Valorizzando `paymentType` con `["CREDITCARD"]` la pagina di pagamento mostra la carta e i wallet abilitati sullo shopLogin, tra cui Google Pay. La richiesta non cambia in base al metodo scelto dal buyer e il token restituito corrisponde al metodo utilizzato. **Integrazione tramite API** Il campo `requestToken` va inserito nella `payment/create`. Nella `payment/submit`, che trasporta il payload Google Pay, il campo **non va ripetuto**. **Request** ```http POST /api/v1/payment/create Host (sandbox): sandbox.gestpay.net Host (produzione): ecomms2s.sella.it Authorization: apikey **************** Content-Type: application/json ``` ```json { "shopLogin": "GESPAY12345", "amount": "100", "currency": "EUR", "shopTransactionID": "FBK_OrderID", "requestToken": "MASKEDPAN" } ``` La `payment/submit` resta quella descritta allo [Step 2](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/alternative-payments/google-pay/#step-2--invio-del-token-e-processamento). Il token è disponibile nella risposta di `payment/detail`, nel campo `payload.token`. Per maggiori informazioni sul token è possibile leggere l'oggetto `payload.tokenDetails`. > **Gestione del token** > > Per la lettura dei dati del token, la sua modifica e la cancellazione consulta [Lettura dati token](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/token/#lettura-dati-token). ### Pagamenti ricorrenti Google Pay può essere utilizzato come metodo di pagamento di una **serie ricorrente**. Il buyer autorizza il primo pagamento della serie (**First**, CIT) con la propria autenticazione, mentre i pagamenti successivi (**Next**, MIT) vengono eseguiti dall'esercente in sua assenza, utilizzando il token ottenuto durante la First. | Transazione | Integrazioni disponibili | Dati da inviare | | --------------- | ----------------------------------- | ------------------------------------------------- | | **First (CIT)** | Integrazioni hosted oppure API Only | Payload Google Pay, oppure un token già esistente | | **Next (MIT)** | API | Token generato o utilizzato nella First | > **I wallet sono gestiti come carte** > > Nelle transazioni Next il token va sempre inviato nel campo `paymentTypeDetails.creditcard.token`, anche quando la First è stata pagata con Google Pay. Il flusso Next è quindi identico a quello della carta. Per il flusso completo, i campi obbligatori della First, i dati da salvare e la gestione del soft decline `8026` consulta [Pagamenti ricorrenti con carta e wallet](https://docs.fabrick.com/payment-hub-and-orchestra/ecommerce/features/recurring-payments/). --- ## Assistenza **Fabrick** - **Status page**: [https://status.fabrick.com/](https://status.fabrick.com/) - **Support**: [https://landing.fabrick.com/fabrick-dashboard-support](https://landing.fabrick.com/fabrick-dashboard-support) **Google** - **Support**: [https://support.google.com/googlepay/](https://support.google.com/googlepay/)