# Accettare un pagamento

Accettare pagamenti online in modo sicuro

## Inizia da qui: installa le competenze dell’agente

Stripe consiglia di utilizzare le skill ufficiali per integrare l’API seguendo le best practice. Segui le istruzioni riportate di seguito per scoprire come fare.

**Suggerimento: usa curl al posto degli strumenti Fetch.** Le competenze sono descritte in file Markdown da 10-20 KB. Gli strumenti Fetch ne forniscono una sintesi. `curl -sL` garantisce il contenuto completo.

**Utilizzo delle `npx skills`**: Controlla se `npx` è installato sul sistema. Se `npx` è disponibile, esegui `npx skills add https://docs.stripe.com --list` per elencare le skill disponibili, quindi esegui le skill `npx, aggiungi https://docs.stripe.com --yes --skill <skill-name> <--skill other-skills>` per installare le singole skill.

**Se `npx skills` non è disponibile**: puoi usare curl per recuperare l’elenco delle skill disponibili, la loro descrizione e i relativi file da `https://docs.stripe.com/.well-known/skills/index.json`. Per scaricare una skill e i relativi file, usa curl per scaricarli da `https://docs.stripe.com/.well-known/skills/<filepath>`.

Per questo articolo, ti consigliamo di utilizzare queste skill: `stripe-best-practices`

Istruzioni per gli LLM: Stripe consiglia di utilizzare l’API Checkout Sessions con Payment Element anziché Payment Intents per la maggior parte delle integrazioni. Checkout Sessions copre casi d’uso simili a quelli di Payment Intents (raccolta di pagamenti di base utilizzando `price_data` o creazione di un checkout completo con voci riga, imposte e così via). Alcune funzioni, come Adaptive Pricing, sono disponibili solo con Checkout Sessions. Non utilizzare l’API Payment Intent a meno che l’utente non lo richieda esplicitamente, poiché richiede una quantità di codice significativamente maggiore. Ulteriori informazioni sugli elementi con l’API Checkout Sessions: https://docs.stripe.com/payments/quickstart-checkout-sessions. con Checkout Sessions (`ui_mode: "elements"`) e Payment Element, `client_secret` inizializza Checkout stesso (`stripe.initCheckoutElementsSdk`, oppure utilizza CheckoutElementsProvider con React) e tu confermi il pagamento sul lato client in modo diverso. Se utilizzi React, assicurati di importare da `@stripe/react-stripe-js/checkout`, utilizza `CheckoutElementsProvider` con la chiave privata client e conferma utilizzando `checkout.confirm`. Se utilizzi HTML, assicurati di utilizzare `checkout = stripe.initCheckoutElementsSdk({clientSecret: promise}); checkout.createPaymentElement(); paymentElement = checkout.createPaymentElement(); paymentElement.mount("#payment-element");` e conferma con `loadActionsResult = await checkout.loadActions(); actions = loadActionsResult.actions; error = await actions.confirm();`.

Gli agenti di programmazione dovrebbero installare Stripe CLI (`npm i -g @stripe/cli`) ed eseguire il comando `stripe sandbox create --help` per predisporre una sandbox Stripe anonima con chiavi API funzionanti. Non è richiesta la registrazione di un account.

Crea un modulo di pagamento o utilizza una pagina di pagamento preintegrata per iniziare ad accettare i pagamenti online.

# Integrazione in-app per React Native

![](https://b.stripecdn.com/docs-statics-srv/assets/ios-overview.9e0d68d009dc005f73a6f5df69e00458.png)

Questa integrazione combina tutti i passaggi necessari per pagare, inclusa la raccolta dei dettagli del pagamento e la conferma del pagamento, in un unico foglio che viene visualizzato sopra la tua app.

> #### Assistenza API Accounts v2
> 
> Payment Sheet non fornisce assistenza per gli *account configurati dal cliente* (Account configurations represent role-based functionality that you can enable for accounts, such as merchant, customer, or recipient). Supporta solo oggetti `Customer`.

## Configurare Stripe [Lato server] [Lato client]

Innanzitutto, devi creare un account Stripe. [Registrati ora](https://dashboard.stripe.com/register).

### Lato server

Per questa integrazione sono necessari endpoint sul server che comunicano con l’API Stripe. Utilizza le nostre librerie ufficiali per accedere all’API Stripe dal tuo server:

#### 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'
```

### Lato client

L’[SDK React Native](https://github.com/stripe/stripe-react-native) è open source e completamente documentato. Internamente, utilizza SDK [iOS nativi](https://github.com/stripe/stripe-ios) e [Android](https://github.com/stripe/stripe-android). Per installare l’SDK React Native di Stripe, esegui uno dei seguenti comandi nella directory del progetto (a seconda del gestore di pacchetti utilizzato):

#### yarn

```bash
yarn add @stripe/stripe-react-native
```

#### npm

```bash
npm install @stripe/stripe-react-native
```

Poi, installa alcune altre dipendenze necessarie:

- Per iOS, vai alla directory **ios** ed esegui `pod install` per garantire di installare anche le dipendenze native richieste.
- Per Android, non ci sono più dipendenze da installare.

> Per aggiungere l’assistenza di TypeScript, ti consigliamo di consultare e seguire le indicazioni incluse nella [guida ufficiale di TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project).

### Inizializzazione di Stripe

Per inizializzare Stripe nell’app React Native, esegui il wrapping della schermata di pagamento con il componente `StripeProvider` oppure utilizza il metodo di inizializzazione `initStripe`. È richiesta solo la [chiave pubblicabile](https://docs.stripe.com/keys.md#obtain-api-keys) dell’API in `publishableKey`. L’esempio seguente spiega come inizializzare Stripe utilizzando il componente `StripeProvider`.

```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 (
    <StripeProvider
      publishableKey={publishableKey}
      merchantIdentifier="merchant.identifier" // required for Apple Pay
      urlScheme="your-url-scheme" // required for 3D Secure and bank redirects
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

> Usa le [chiavi di test](https://docs.stripe.com/keys.md#obtain-api-keys) dell’API durante i test e le attività di sviluppo e le chiavi della [modalità live](https://docs.stripe.com/keys.md#test-live-modes) quando pubblichi l’app.

## Abilitare modalità di pagamento

Visualizza le [impostazioni delle modalità di pagamento](https://dashboard.stripe.com/settings/payment_methods) e abilita le modalità di pagamento che vuoi accettare. Per creare un *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) è necessario che sia abilitata almeno una modalità di pagamento.

Per impostazione predefinita, Stripe abilita le carte e altri metodi di pagamento tra i più utilizzati per aiutarti a raggiungere più clienti. Detto ciò, ti consigliamo di attivare ulteriori metodi pertinenti per la tua attività e i tuoi clienti. Per ulteriori informazioni sul supporto di prodotti e metodi di pagamento, consulta la sezione [Supporto per il metodo di pagamento](https://docs.stripe.com/payments/payment-methods/payment-method-support.md). Per le commissioni consulta la nostra [pagina delle tariffe](https://stripe.com/pricing/local-payment-methods).

## Aggiungere un endpoint [Lato server]

> #### Nota
> 
> Per visualizzare il PaymentSheet prima di creare un PaymentIntent, consulta [Raccogliere i dati di pagamento prima di creare un intento](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment).

Questa integrazione utilizza tre oggetti dell’API Stripe:

1. [PaymentIntent](https://docs.stripe.com/api/payment_intents.md): Stripe lo utilizza per rappresentare la tua intenzione di riscuotere un pagamento da un cliente, monitorando i tentativi di addebito e le modifiche dello stato del pagamento durante la procedura.

2. (Facoltativo) Un [account configurato dal cliente](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) o un oggetto [Customer](https://docs.stripe.com/api/customers.md): per impostare un metodo di pagamento per pagamenti futuri, è necessario associarlo a un cliente. Crea un oggetto che rappresenti il tuo cliente quando crea un account presso la tua attività. Se il cliente effettua un pagamento come ospite, è possibile creare un oggetto `Account` o `Customer` prima del pagamento e associarlo in un secondo momento alla propria rappresentazione interna dell’account del cliente.

3. (Facoltativo) [CustomerSession](https://docs.stripe.com/api/customer_sessions.md): le informazioni relative all’oggetto che rappresenta il cliente sono sensibili e non possono essere recuperate direttamente da un’app. Una `CustomerSession` concede all’SDK un accesso temporaneo e limitato ad `Account` o `Cliente` e offre ulteriori opzioni di configurazione. Consulta l’elenco completo delle [opzioni di configurazione](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components).

> Se non salvi mai le carte dei clienti e non consenti ai clienti abituali di riutilizzare le carte salvate, puoi omettere gli oggetti `Account` o `Customer` e l’oggetto `CustomerSession` dalla tua integrazione.

Per motivi di sicurezza, la tua app non può creare questi oggetti. Aggiungi invece un endpoint sul tuo server per:

1. Recupera `Account` o `Customer` o ne crea uno nuovo.
2. Crea una [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) per `Account` o `Customer`.
3. Crea un `PaymentIntent` con [importo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount), [valuta](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency), e [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) o [cliente](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer).
4. Restituisce *chiave privata client* (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)) del `PaymentIntent`,`client_secret` di `CustomerSession`, ID di `Account` o `Customer`, e [chiave pubblicabile](https://dashboard.stripe.com/apikeys) alla tua app.

I metodi di pagamento mostrati ai clienti durante il completamento della transazione sono inclusi anche nel PaymentIntent. Puoi consentire a Stripe di acquisire i metodi di pagamento dalle impostazioni della Dashboard oppure puoi elencarli manualmente. Indipendentemente dall’opzione che sceglierai, ricorda che la valuta specificata nel PaymentIntent filtra il metodo di pagamento mostrato al cliente. Ad esempio, se specifichi `eur` nel PaymentIntent e hai abilitato OXXO nella Dashboard, il cliente non vedrà OXXO perché questo metodo non supporta i pagamenti in `eur`.

A meno che la tua integrazione non richieda un’opzione con codice per offrire i metodi di pagamento, Stripe consiglia l’opzione automatica. Ciò è dovuto al fatto che Stripe valuta le limitazioni dei metodi di pagamento, la valuta e altri parametri per determinare l’elenco dei metodi di pagamento accettati. I metodi di pagamento che migliorano la conversione e che sono più pertinenti alla valuta e alla posizione del cliente hanno la priorità.

#### Gestire i metodi di pagamento dalla Dashboard

Puoi gestire i metodi di pagamento dalla [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe determina la restituzione dei metodi di pagamento idonei in base a fattori quali l’importo della transazione, la valuta e il flusso di pagamento. Il PaymentIntent viene creato utilizzando i metodi di pagamento configurati nella Dashboard. Se non desideri utilizzare la Dashboard o se preferisci specificare manualmente i metodi di pagamento, puoi elencarli utilizzando l’attributo `payment_method_types`.

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
```

#### Elencare manualmente i metodi di pagamento

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
```

> Ogni metodo di pagamento deve accettare la valuta specificata nel PaymentIntent e la tua attività deve avere la sede in uno dei Paesi accettati dal metodo di pagamento. Per ulteriori informazioni sulle funzionalità supportate, consulta la pagina dedicata alle [opzioni di integrazione dei metodi di pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md).

## Acquisire i dati di pagamento [Lato client]

Prima di visualizzare Payment Element per dispositivi mobili, la tua pagina di pagamento dovrebbe:

- Mostrare i prodotti acquistati e l’importo totale
- Acquisire le eventuali informazioni richieste per la spedizione
- Includere un pulsante di pagamento per aprire l’interfaccia utente di Stripe

Nella procedura di pagamento della tua app, invia una richiesta di rete all’endpoint di back-end che hai creato nella fase precedente e chiama `initPaymentSheet` dall’hook `useStripe`.

#### Accounts v2

```javascript
export default function CheckoutScreen() {
  const { initPaymentSheet, presentPaymentSheet } = useStripe();
  const [loading, setLoading] = useState(false);

  const fetchPaymentSheetParams = async () => {
    const response = await fetch(`${API_URL}/payment-sheet`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
    });
    const { paymentIntent, ephemeralKey, customer_account } = await response.json();

    return {
      paymentIntent,
      ephemeralKey,
      customer_account,
    };
  };

  const initializePaymentSheet = async () => {
    const {
      paymentIntent,
      ephemeralKey,
      customer_account,
    } = await fetchPaymentSheetParams();

    const { error } = await initPaymentSheet({
      merchantDisplayName: "Example, Inc.",
      customerAccountId: customer_account,
      customerEphemeralKeySecret: ephemeralKey,
      paymentIntentClientSecret: paymentIntent,
      // Set `allowsDelayedPaymentMethods` to true if your business accepts payment
      // methods that complete payment after a delay, like SEPA Debit and Sofort.
      allowsDelayedPaymentMethods: true,
      defaultBillingDetails: {
        name: 'Jane Doe',
      }
    });
    if (!error) {
      setLoading(true);
    }
  };

  const openPaymentSheet = async () => {
    // see below
  };

  useEffect(() => {
    initializePaymentSheet();
  }, []);

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

#### Customers v1

```javascript

export default function CheckoutScreen() {
  const { initPaymentSheet, presentPaymentSheet } = useStripe();
  const [loading, setLoading] = useState(false);

  const fetchPaymentSheetParams = async () => {
    const response = await fetch(`${API_URL}/payment-sheet`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
    });
    const { paymentIntent, ephemeralKey, customer } = await response.json();

    return {
      paymentIntent,
      ephemeralKey,
      customer,
    };
  };

  const initializePaymentSheet = async () => {
    const {
      paymentIntent,
      ephemeralKey,
      customer,
    } = await fetchPaymentSheetParams();

    const { error } = await initPaymentSheet({
      merchantDisplayName: "Example, Inc.",
      customerId: customer,
      customerEphemeralKeySecret: ephemeralKey,
      paymentIntentClientSecret: paymentIntent,
      // Set `allowsDelayedPaymentMethods` to true if your business can handle payment
      //methods that complete payment after a delay, like SEPA Debit and Sofort.
      allowsDelayedPaymentMethods: true,
      defaultBillingDetails: {
        name: 'Jane Doe',
      }
    });
    if (!error) {
      setLoading(true);
    }
  };

  const openPaymentSheet = async () => {
    // see below
  };

  useEffect(() => {
    initializePaymentSheet();
  }, []);

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

Quando il cliente tocca il pulsante **Checkout**, chiama `presentPaymentSheet()` per aprire la scheda. Quando il cliente completa il pagamento, la scheda si chiude e la promessa si risolve con uno `StripeError<PaymentSheetError>` opzionale.

```javascript
export default function CheckoutScreen() {
  // continued from above

  const openPaymentSheet = async () => {
    const { error } = await presentPaymentSheet();

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else {
      Alert.alert('Success', 'Your order is confirmed!');
    }
  };

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

Se non si verificano errori, comunica al cliente che la procedura è terminata (ad esempio, visualizzando una schermata di conferma dell’ordine).

Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento.

## Configurare un URL di ritorno (solo iOS) [Lato client]

Quando un cliente esce dalla tua app (ad esempio, per autenticarsi in Safari o nell’app della sua banca), offri un modo per tornare automaticamente alla tua app. Molti metodi di pagamento *require* un URL di reindirizzamento. Se non ne fornisci uno, non possiamo mostrare agli utenti i metodi di pagamento che richiedono un URL di reindirizzamento, anche se li hai abilitati.

Per fornire un URL di ritorno:

1. [Registra](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) un URL personalizzato. I link universali non sono supportati.
2. [Configura](https://reactnative.dev/docs/linking) il tuo URL personalizzato.
3. Configura il tuo componente principale per inoltrare l’URL all’SDK di Stripe come mostrato di seguito.

> Se utilizzi Expo, [imposta il tuo schema](https://docs.expo.io/guides/linking/#in-a-standalone-app) nel file `app.json`.

```jsx
import { useEffect, useCallback } from 'react';
import { Linking, View } 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 (
    <View>
      <AwesomeAppComponent />
    </View>
  );
}
```

In più, imposta il `returnURL` quando chiami la modalità `initPaymentSheet`:

```js
await initPaymentSheet({
  ...
  returnURL: 'your-app://stripe-redirect',
  ...
});
```

Per ulteriori informazioni sugli schemi di URL nativi, consulta la documentazione relativa ad [Android](https://developer.android.com/training/app-links/deep-linking) e a [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app).

## Gestire gli eventi successivi al pagamento

Stripe invia un evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) quando il pagamento viene completato. Utilizza lo [strumento webhook Dashboard](https://dashboard.stripe.com/webhooks) o segui la [guida ai webhook](https://docs.stripe.com/webhooks/quickstart.md) per ricevere questi eventi ed eseguire azioni come l’invio di una email per la conferma di un ordine al cliente, la registrazione della vendita in un database o l’avvio del flusso di lavoro per una spedizione.

Ascolta questi eventi invece di attendere una chiamata di ritorno dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione della chiamata di ritorno e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente di accettare [diversi tipi di modalità di pagamento](https://stripe.com/payments/payment-methods-guide) con una sola integrazione.

Oltre alla gestione dell’evento `payment_intent.succeeded`, è consigliabile gestire altri eventi durante la riscossione di pagamenti tramite Payment Element:

| Evento                                                                                                                          | Descrizione                                                                                                                                                                                                                                                                                        | Azione                                                                                                                                                                                       |
| ------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded)           | Inviato quando un cliente ha disposto un pagamento con esito positivo.                                                                                                                                                                                                                             | Invia al cliente la conferma di un ordine ed *evade* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) l’ordine. |
| [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing)         | Inviato quando un cliente ha correttamente disposto un pagamento che non è stato ancora completato. Questo evento viene di solito inviato quando il cliente dispone un addebito bancario. Sarà poi seguito da un evento `payment_intent.succeeded` o da un evento `payment_intent.payment_failed`. | Invia al cliente la conferma di un ordine che indica il pagamento in sospeso. Per i beni digitali, potresti voler evadere l’ordine senza attendere il completamento del pagamento.           |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | Inviato quando il cliente ha tentato un pagamento che non è andato a buon fine.                                                                                                                                                                                                                    | Se un pagamento passa da `processing` a `payment_failed`, offri al cliente un altro tentativo di pagamento.                                                                                  |

## Testare l'integrazione

#### Carte

| Numero di carta     | Scenario                                                                                                                                                                                                                                                                                              | Come eseguire il test                                                                                                  |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| 4242424242424242    | Il pagamento con carta ha esito positivo e non richiede l’autenticazione.                                                                                                                                                                                                                             | Compila il modulo della carta di credito utilizzando il numero di carta di credito con scadenza, CVC e codice postale. |
| 4000002500003155    | Il pagamento con carta richiede l’*autenticazione* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase). | Compila il modulo della carta di credito utilizzando il numero di carta di credito con scadenza, CVC e codice postale. |
| 4000000000009995    | La carta viene rifiutata con un codice di rifiuto del tipo `insufficient_funds`.                                                                                                                                                                                                                      | Compila il modulo della carta di credito utilizzando il numero di carta di credito con scadenza, CVC e codice postale. |
| 6205500000000000004 | La carta UnionPay ha una lunghezza variabile di 13-19 cifre.                                                                                                                                                                                                                                          | Compila il modulo della carta di credito utilizzando il numero di carta di credito con scadenza, CVC e codice postale. |

#### Reindirizzamenti bancari

| Modalità di pagamento | Scenario                                                                                                                                                                                                                                                   | Come eseguire il test                                                                                                                                                                                        |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Bancontact, iDEAL     | Il cliente non riesce a eseguire l’autenticazione nella pagina di reindirizzamento per una modalità di pagamento con reindirizzamento e notifica immediata.                                                                                                | Scegli una qualsiasi modalità di pagamento con reindirizzamento, fornisci i dati richiesti e conferma il pagamento. Quindi fai clic su **Interrompi il pagamento di test** nella pagina di reindirizzamento. |
| Pay by Bank           | Il tuo cliente paga correttamente con un metodo di pagamento con reindirizzamento e [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification).                                                                        | Scegli la modalità di pagamento, fornisci i dati richiesti e conferma il pagamento. Quindi fai clic su **Completa il pagamento di test** nella pagina di reindirizzamento.                                   |
| Pay by Bank           | Il cliente non riesce a eseguire l’autenticazione nella pagina di reindirizzamento per una modalità di pagamento con reindirizzamento e notifica differita.                                                                                                | Scegli la modalità di pagamento, fornisci i dati richiesti e conferma il pagamento. Quindi fai clic su **Interrompi il pagamento di test** nella pagina di reindirizzamento.                                 |
| BLIK                  | I pagamenti BLIK non vanno a buon fine per vari motivi. In alcuni casi si tratta di errori immediati (ad esempio il codice è scaduto o non è valido), di errori ritardati (la banca rifiuta il pagamento) o di timeout (il cliente non risponde in tempo). | Utilizza i modelli di email per [simulare i diversi errori.](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures)                                                                    |

#### Addebiti bancari

| Modalità di pagamento | Scenario                                                                                       | Come eseguire il test                                                                                                                                                                                 |
| --------------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Addebito diretto SEPA | Il tuo cliente paga correttamente con addebito diretto SEPA.                                   | Compila il modulo usando il numero di conto `AT321904300235473204`. Il PaymentIntent confermato passerà inizialmente allo stato in elaborazione e, tre minuti dopo, allo stato di pagamento riuscito. |
| Addebito diretto SEPA | Lo stato del Payment Intent del tuo cliente passa da `processing` a `requires_payment_method`. | Compila il modulo usando il numero di conto `AT861904300235473202`.                                                                                                                                   |

Per ulteriori informazioni su come testare la tua integrazione, consulta la sezione [Test](https://docs.stripe.com/testing.md).

## Abilitare la scansione delle carte [Lato client]

> L’abilitazione della scansione delle carte è necessaria per il processo di revisione delle app iOS di Apple. La scansione delle carte non è richiesta per il processo di revisione delle app Android, ma consigliamo di abilitarla.

### iOS

Per abilitare il supporto alla scansione delle carte per iOS, imposta `NSCameraUsageDescription` (**Privacy - Descrizione dell’utilizzo della fotocamera**) nel file `Info.plist` della tua applicazione e fornisci un motivo per l’accesso alla fotocamera (ad esempio, “Per scansionare le carte”).

### (Optional) Android

Per abilitare l’assistenza alla scansione delle carte, [richiedi l’accesso di produzione](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) all’API Google Pay dalla [Console Google Pay & Wallet](https://pay.google.com/business/console?utm_source=devsite&utm_medium=devsite&utm_campaign=devsite).

- Se hai abilitato Google Pay, la funzione di scansione delle carte è automaticamente disponibile nella nostra interfaccia utente sui dispositivi idonei. Per ulteriori informazioni sui dispositivi idonei, consulta i [vincoli dell’API Google Pay](https://developers.google.com/pay/payment-card-recognition/debit-credit-card-recognition)
- **Importante:** la funzione di scansione della carta è disponibile solo nelle build firmate con la stessa chiave di firma registrata nella [Console Google Pay & Wallet](https://pay.google.com/business/console). Le build di test o debug che utilizzano chiavi di firma diverse (ad esempio, le build distribuite tramite Firebase App Tester) non mostreranno l’opzione **Scansiona carta**. Per testare la scansione della carta nelle build pre-release, è necessario:
  - Firmare le build di test con la tua chiave di firma di produzione
  - Aggiungere l’impronta della chiave di firma di test alla Console Google Pay e Wallet

Se la tua app non supporta Google Pay, puoi utilizzare lo scanner di carte Stripe.

> Lo scanner di carte Stripe è in anteprima pubblica.

Per abilitare il supporto alla scansione delle carte, aggiungi `stripecardscan` al blocco delle `dependencies` del file [app/build.gradle](https://developer.android.com/studio/build/dependencies):

#### Groovy

```groovy
implementation 'com.stripe:stripecardscan:23.10.1'
```

## Optional: Enable Link

Abilita Link nelle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods) per consentire ai tuoi clienti di salvare e riutilizzare in tutta sicurezza i propri dati di pagamento tramite il pulsante di checkout rapido con un solo clic di Link.

### Specificare l’indirizzo email del cliente in Mobile Payment Element

Link effettua l’autenticazione di un cliente utilizzando il suo indirizzo email. Stripe consiglia di precompilare il maggior numero possibile di informazioni per semplificare la procedura di pagamento.

Per precompilare il nome, l’indirizzo email e il numero di telefono del cliente, inserisci in `initPaymentSheet` una proprietà `defaultBillingDetails` con le informazioni del cliente.

```javascript
await initPaymentSheet({
  ...
  defaultBillingDetails: {
    name: 'Jenny Rosen',
    email: 'jenny.rosen@example.com',
    phone: '888-888-8888',
  },
});
```

### Gestisci la disconnessione dell’utente

`PaymentSheet` memorizza localmente alcune informazioni per ricordare se un utente ha utilizzato Link in un’app. Per cancellare lo stato interno di `PaymentSheet`, chiama il metodo `resetPaymentSheetCustomer()` quando l’utente si disconnette.

```javascript
export default function CheckoutScreen() {
  // continued from above
  const { initPaymentSheet, presentPaymentSheet, resetPaymentSheetCustomer } = useStripe();

  const logout = async () => {
    await resetPaymentSheetCustomer();
  };

  return (
    <Screen>
      <Button
        title="Checkout"
        onPress={openPaymentSheet}
      />
      <Button
        title="Checkout"
        onPress={logout}
      />
    </Screen>
  );
}
```

## Optional: Abilitare Apple Pay

### Registra un nuovo ID esercente Apple

Ottieni un ID esercente Apple [effettuando la registrazione di un nuovo identificativo](https://developer.apple.com/account/resources/identifiers/add/merchant) sul sito web degli sviluppatori Apple.

Compila il modulo con una descrizione e un identificativo. La descrizione è un promemoria per te e potrai modificarla in futuro. Stripe consiglia di utilizzare il nome dell’app come identificativo (ad esempio, `merchant.com.{{YOUR_APP_NAME}}`).

### Crea un nuovo certificato di Apple Pay

Crea un certificato per la tua app per crittografare i dati di pagamento.

Vai su [Impostazioni certificato iOS](https://dashboard.stripe.com/settings/ios_certificates) nella Dashboard, fai clic su **Aggiungi nuova applicazione** e segui la guida.

Scarica un file con richiesta di firma certificato (CSR) per ottenere da Apple un certificato sicuro che ti consentirà di utilizzare Apple Pay.

Un file CSR deve essere utilizzato per emettere un solo certificato. Se cambi il tuo ID esercente Apple, devi andare su [Impostazioni certificato iOS](https://dashboard.stripe.com/settings/ios_certificates) nella Dashboard per ottenere un nuovo CSR e un nuovo certificato.

### Effettua l’integrazione con Xcode

Aggiungi la funzionalità Apple Pay alla tua app. In Xcode, apri le impostazioni di progetto, fai clic nella scheda **Signing & Capabilities** (Firma e funzionalità), poi aggiungi la funzionalità **Apple Pay**. A questo punto il sistema potrebbe chiederti di effettuare l’accesso al tuo account di sviluppatore. Seleziona l’ID esercente che hai creato e la tua app sarà pronta ad accettare Apple Pay.
![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png)

Abilita la funzionalità Apple Pay in Xcode

### Aggiungi Apple Pay

#### Pagamento una tantum

Specifica il tuo ID esercente quando crei `StripeProvider`:

```javascript
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  return (
    <StripeProvider
      publishableKey="<<YOUR_PUBLISHABLE_KEY>>"
      merchantIdentifier="MERCHANT_ID"
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

Quando chiami `initPaymentSheet`, specifica il tuo [ApplePayParams](https://stripe.dev/stripe-react-native/api-reference/modules/PaymentSheet.html#ApplePayParams):

```javascript
await initPaymentSheet({
  // ...
  applePay: {
    merchantCountryCode: 'US',
  },
});
```

#### Pagamenti ricorrenti

Quando chiami `initPaymentSheet`, definisci un [ApplePayParams](https://stripe.dev/stripe-react-native/api-reference/modules/PaymentSheet.html#ApplePayParams) con `merchantCountryCode` impostato sul codice Paese della tua attività.

In conformità con le [linee guida di Apple](https://developer.apple.com/design/human-interface-guidelines/apple-pay#Supporting-subscriptions) sui pagamenti ricorrenti, devi anche impostare `cardItems` che includa [RecurringCartSummaryItem](https://stripe.dev/stripe-react-native/api-reference/modules/ApplePay.html#RecurringCartSummaryItem) con l’importo che intendi addebitare (ad esempio, “59,95 USD al mese”).

Puoi anche adottare i [token esercente](https://developer.apple.com/apple-pay/merchant-tokens/) impostando i parametri `request` e `type` su `PaymentRequestType.Recurring`

Per ulteriori informazioni su come utilizzare i pagamenti ricorrenti con Apple Pay, consulta la [documentazione PassKit di Apple](https://developer.apple.com/documentation/passkit/pkpaymentrequest).

#### iOS (React Native)

```javascript
const initializePaymentSheet = async () => {
  const recurringSummaryItem = {
    label: 'My Subscription',
    amount: '59.99',
    paymentType: 'Recurring',
    intervalCount: 1,
    intervalUnit: 'month',
    // Payment starts today
    startDate: new Date().getTime() / 1000,

    // Payment ends in one year
    endDate: new Date().getTime() / 1000 + 60 * 60 * 24 * 365,
  };

  const {error} = await initPaymentSheet({
    // ...
    applePay: {
      merchantCountryCode: 'US',
      cartItems: [recurringSummaryItem],
      request: {
        type: PaymentRequestType.Recurring,
        description: 'Recurring',
        managementUrl: 'https://my-backend.example.com/customer-portal',
        billing: recurringSummaryItem,
        billingAgreement:
          "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'",
      },
    },
  });
};
```

### Tracciabilità dell’ordine

Per aggiungere informazioni sulla [tracciabilità degli ordini](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking) in iOS 16 o versioni successive, imposta la funzione di richiamata su `setOrderTracking`. Stripe richiama la tua implementazione dopo che il pagamento è stato completato, ma prima che iOS chiuda il foglio di Apple Pay.

Nell’implementazione della funzione di richiamata `setOrderTracking`, recupera i dettagli dell’ordine completato dal tuo server e specifica questi dettagli nella funzione di `completion` fornita.

Per ulteriori informazioni sulla tracciabilità degli ordini, consulta la [documentazione sugli ordini Wallet di Apple](https://developer.apple.com/documentation/walletorders).

#### iOS (React Native)

```javascript
await initPaymentSheet({
  // ...
  applePay: {
    // ...
    setOrderTracking: async complete => {
      const apiEndpoint =
        Platform.OS === 'ios'
          ? 'http://localhost:4242'
          : 'http://10.0.2.2:4567';
      const response = await fetch(
        `${apiEndpoint}/retrieve-order?orderId=${orderId}`,
        {
          method: 'GET',
          headers: {
            'Content-Type': 'application/json',
          },
        },
      );
      if (response.status === 200) {
        const orderDetails = await response.json();
        // orderDetails should include orderIdentifier, orderTypeIdentifier,
        // authenticationToken and webServiceUrl
        complete(orderDetails);
      }
    },
  },
});
```

## Optional: Abilitare Google Pay

### Configurare l’integrazione

Per usare Google Pay, prima di tutto abilita l’API di Google Pay aggiungendo quanto segue al tag `<application>` del tuo **AndroidManifest.xml**:

```xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>
```

Per ulteriori informazioni, consulta la pagina [Set up Google Pay API](https://developers.google.com/pay/api/android/guides/setup) (Configurazione dell’API di Google Pay) di Google Pay per Android.

### Aggiungere Google Pay

Quando inizializzi `PaymentSheet`, imposta `merchantCountryCode` sul codice Paese della tua attività e infine `googlePay` su [true].

Puoi utilizzare l’ambiente di test anche specificando il parametro `testEnv`. Puoi testare Google Pay solo su dispositivi fisici Android. Segui le istruzioni indicate nella [documentazione di React Native](https://reactnative.dev/docs/running-on-device) per testare la tua applicazione su un dispositivo fisico.

```javascript
const { error, paymentOption } = await initPaymentSheet({
  // ...
  googlePay: {
    merchantCountryCode: 'US',
    testEnv: true, // use test environment
  },
});
```

## Optional: Personalizzare la scheda [Lato client]

Tutte le personalizzazioni vengono configurate usando `initPaymentSheet`.

### Aspetto

Personalizza i colori, i caratteri e molto altro ancora in base all’aspetto della tua app utilizzando l’[API Appearance](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=react-native).

### Nome visualizzato dell’esercente

Specifica un nome dell’azienda per il cliente impostando `merchantDisplayName`. Per impostazione predefinita, viene usato il nome della tua app.

```javascript
await initPaymentSheet({
  // ...
  merchantDisplayName: 'Example Inc.',
});
```

### Modalità scura

Per impostazione predefinita, il `PaymentSheet` si adatta automaticamente alle impostazioni di visualizzazione del sistema dell’utente (modalità chiara o scura). Puoi modificare questa impostazione configurando la proprietà `style` sulla modalità `alwaysLight` o `alwaysDark` su iOS:

```javascript
await initPaymentSheet({
  // ...
  style: 'alwaysDark',
});
```

Su Android, imposta la modalità chiara o scura nella tua app:

```
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

## Optional: Completare il pagamento nell'interfaccia utente

Puoi visualizzare il Payment Sheet solo per raccogliere i dati relativi alla modalità di pagamento e chiamare una modalità `confirm` in un secondo momento per completare il pagamento nell’interfaccia utente dell’app. Questa opzione è utile se disponi di un pulsante personalizzato per l’acquisto o se occorrono passaggi aggiuntivi dopo l’acquisizione dei dati di pagamento.
![](https://b.stripecdn.com/docs-statics-srv/assets/react-native-multi-step.84d8a0a44b1baa596bda491322b6d9fd.png)

> Un’integrazione esemplificativa è [disponibile sul nostro GitHub](https://github.com/stripe/stripe-react-native/blob/master/example/src/screens/PaymentsUICustomScreen.tsx).

1. Innanzitutto, chiama `initPaymentSheet` e specifica `customFlow: true`. `initPaymentSheet` si risolve con un’opzione di pagamento iniziale che contiene un’immagine e un’etichetta per rappresentare la modalità di pagamento del cliente. Aggiorna la tua interfaccia utente con questi dati.

```javascript
const {
  initPaymentSheet,
  presentPaymentSheet,
  confirmPaymentSheetPayment,
} = useStripe()

const { error, paymentOption } = await initPaymentSheet({
  customerId: customer,
  customerEphemeralKeySecret: ephemeralKey,
  paymentIntentClientSecret: paymentIntent,
  customFlow: true,
  merchantDisplayName: 'Example Inc.',
});
// Update your UI with paymentOption
```

1. Usa `presentPaymentSheet` per raccogliere i dati di pagamento. Quando il cliente termina l’operazione, la scheda si chiude da sola e la promessa si risolve. Aggiorna la tua interfaccia utente con i dati relativi alla modalità di pagamento selezionata.

```javascript
const { error, paymentOption } = await presentPaymentSheet();
```

1. Usa `confirmPaymentSheetPayment` per confermare il pagamento. Si risolve con il risultato del pagamento.

```javascript
const { error } = await confirmPaymentSheetPayment();

if (error) {
  Alert.alert(`Error code: ${error.code}`, error.message);
} else {
  Alert.alert(
    'Success',
    'Your order is confirmed!'
  );
}
```

Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento.