# Accettare un pagamento Afterpay o Clearpay

Scopri come accettare Afterpay (nota anche come Clearpay nel Regno Unito), una modalità di pagamento utilizzata in Stati Uniti, Canada, Regno Unito, Australia e Nuova Zelanda.

> Stripe può presentare automaticamente i metodi di pagamento pertinenti ai tuoi clienti valutando la valuta, le limitazioni relative ai metodi di pagamento e altri parametri.
> 
> - Segui la guida [Accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted) per creare un’integrazione di checkout che utilizzi [metodi di pagamento dinamici](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md).
- Se non desideri utilizzare metodi di pagamento dinamici, segui i passaggi riportati di seguito per configurare manualmente i metodi di pagamento nell’integrazione Checkout.

Afterpay è un metodo di pagamento [monouso](https://docs.stripe.com/payments/payment-methods.md#usage) con [notifica immediata](https://docs.stripe.com/payments/payment-methods.md#payment-notification) che richiede ai clienti di [autenticare](https://docs.stripe.com/payments/payment-methods.md#customer-actions) il pagamento. I clienti vengono reindirizzati al sito Afterpay dove possono accettare i termini di un piano di rateizzazione. Quando il cliente accetta i termini, Afterpay garantisce la disponibilità dei fondi del cliente e li trasferisce sul tuo account Stripe. Il cliente ripaga direttamente Afterpay nel tempo.

> Prima di avviare l’integrazione, assicurati che il tuo account sia idoneo per Afterpay accedendo alle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods).

## Determinare la compatibilità

**Area geografica del cliente**: Australia, Canada, New Zealand, UK, US

**Valute accettate**: `aud, cad, nzd, gbp, usd`

**Valute di pagamento**: `aud, cad, nzd, gbp, usd`

**Metodi di pagamento**: Yes

**Modalità di configurazione**: No

**Modalità di abbonamento**: No

Per supportare i pagamenti Afterpay, una sessione di Checkout deve soddisfare tutte le seguenti condizioni:

- Puoi usare solo le voci riga una tantum (i piani di *abbonamento* (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) ricorrenti non sono supportati).
- I *prezzi* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) devono essere indicati nella valuta nazionale.

## Accettare un pagamento

> Questa guida si basa sull’integrazione di Checkout che permette di [accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted).

Questa guida ti guida nell’abilitazione di Afterpay e mostra le differenze tra accettare pagamenti con metodi di pagamento dinamici e la configurazione manuale dei metodi di pagamento.

### Abilitare Afterpay come modalità di pagamento

Quando crei una nuova [sessione di Checkout](https://docs.stripe.com/api/checkout/sessions.md), devi:

1. Aggiungere `afterpay_clearpay` all’elenco `payment_method_types`.
1. Assicurati che tutti i tuoi `line_items` siano espresse nella tua valuta nazionale e che l’importo totale non superi i [limiti di transazione](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay.
1. Facoltativamente, specificare quali Paesi Checkout consente come destinazioni di spedizione tramite `shipping_address_collection[allowed_countries]`.

#### Pagina in hosting su Stripe

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=afterpay_clearpay" \
  -d "shipping_address_collection[allowed_countries][0]=AU" \
  -d "shipping_address_collection[allowed_countries][1]=CA" \
  -d "shipping_address_collection[allowed_countries][2]=GB" \
  -d "shipping_address_collection[allowed_countries][3]=NZ" \
  -d "shipping_address_collection[allowed_countries][4]=US" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Pagina completamente incorporata

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=afterpay_clearpay" \
  --data-urlencode "return_url=https://example.com/return" \
  -d "shipping_address_collection[allowed_countries][0]=AU" \
  -d "shipping_address_collection[allowed_countries][1]=CA" \
  -d "shipping_address_collection[allowed_countries][2]=GB" \
  -d "shipping_address_collection[allowed_countries][3]=NZ" \
  -d "shipping_address_collection[allowed_countries][4]=US" \
  -d ui_mode=embedded_page
```

Se non desideri la riscossione degli indirizzi di spedizione con Checkout, puoi anche fornire l’indirizzo di spedizione utilizzando `payment_intent_data[shipping]`. Ciò contribuisce ad aumentare i tassi di accettazione dei prestiti.

#### Pagina in hosting su Stripe

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_intent_data[shipping][name]=Jenny Rosen" \
  -d "payment_intent_data[shipping][address][line1]=1234 Main Street" \
  -d "payment_intent_data[shipping][address][city]=San Francisco" \
  -d "payment_intent_data[shipping][address][state]=CA" \
  -d "payment_intent_data[shipping][address][country]=US" \
  -d "payment_intent_data[shipping][address][postal_code]=94111" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=afterpay_clearpay" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Pagina completamente incorporata

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_intent_data[shipping][name]=Jenny Rosen" \
  -d "payment_intent_data[shipping][address][line1]=1234 Main Street" \
  -d "payment_intent_data[shipping][address][city]=San Francisco" \
  -d "payment_intent_data[shipping][address][state]=CA" \
  -d "payment_intent_data[shipping][address][country]=US" \
  -d "payment_intent_data[shipping][address][postal_code]=94111" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=afterpay_clearpay" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

### Evadere gli ordini

[Utilizza un metodo come i webhook](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) per gestire l’*evasione* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) degli ordini, senza aspettare che il cliente torni alla pagina dello stato dei pagamenti.

Gli eventi indicati di seguito vengono inviati al variare dello stato del pagamento:

| Nome evento                                                                                                            | Descrizione                                                                                                                                          | Passaggi successivi                                                      |
| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed)       | Il cliente ha autorizzato il pagamento inviando il modulo di Checkout.                                                                               | Attendi che il pagamento vada a buon fine o meno.                        |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)           | Il pagamento del cliente è andato a buon fine. Lo stato del `PaymentIntent` passa a `succeeded`.                                                     | Evadi l’ordine dei prodotti o dei servizi acquistati dal cliente.        |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed) | Il pagamento del cliente è stato rifiutato o non è andato a buon fine per altri motivi. Il `PaymentIntent` torna in stato `requires_payment_method`. | Contatta il cliente via email e chiedigli di effettuare un nuovo ordine. |

Ulteriori informazioni sull’[evasione degli ordini](https://docs.stripe.com/checkout/fulfillment.md).

## Testare la tua integrazione

Quando testi la tua integrazione di Checkout, seleziona Afterpay come modalità di pagamento e fai clic sul pulsante **Paga**.

Testa la tua integrazione Afterpay con le tue chiavi API di test visualizzando la pagina di reindirizzamento. Puoi testare il caso di pagamento riuscito autenticando il pagamento sulla pagina di reindirizzamento. Il PaymentIntent passerà da `requires_action` a `succeeded`.

Per testare il caso in cui l’utente non riesce a effettuare l’autenticazione, usa le tue chiavi API di test e visualizza la pagina di reindirizzamento. In questa pagina, fai clic su **Interrompi pagamento di test**. Il PaymentIntent passerà da `requires_action` a `requires_payment_method`.

Per i PaymentIntent con [acquisizione manuale](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) in modalità di test, il PaymentIntent non acquisito scade automaticamente 10 minuti dopo che viene concessa l’autorizzazione.

## Pagamenti non riusciti

Afterpay decide se accettare o rifiutare una transazione in base a diversi fattori, ad esempio da quanto tempo l’acquirente utilizza Afterpay, l’importo in sospeso che il cliente deve rimborsare o il valore dell’ordine corrente.

Dato che i pagamenti Afterpay hanno un tasso di rifiuto più elevato rispetto a molti metodi di pagamento, dovresti sempre includere opzioni di pagamento aggiuntive nel tuo flusso di pagamento, come ad esempio `card`. In questi casi, il [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) viene scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) diventa automaticamente a `requires_payment_method`.

Per un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) Afterpay con stato `requires_action`, i clienti devono completare il pagamento entro tre ore dal reindirizzamento al sito Afterpay (ciò non riguarda i pagamenti rifiutati). In caso contrario, l’oggetto [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) verrà scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) passerà automaticamente a `requires_payment_method`

In questi casi, invita il cliente a riprovare con una diversa opzione di pagamento presente nel tuo flusso di completamento della transazione.

## Codici di errore

Questi sono i codici di errore più diffusi e le corrispondenti azioni consigliate:

| Codice di errore                         | Azione consigliata                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Un errore generico che indica che Afterpay Checkout non è andato a buon fine. Può trattarsi anche di un pagamento rifiutato che non viene visualizzato come codice di errore pagamento rifiutato.                                                                                                                    |
| `payment_method_provider_decline`        | Afterpay ha rifiutato il pagamento del cliente. Successivamente, il cliente dovrà contattare Afterpay per richiedere ulteriori informazioni.                                                                                                                                                                         |
| `payment_intent_payment_attempt_expired` | Il cliente non ha mai completato il pagamento sulla pagina di completamento della transazione di Afterpay e la sessione di pagamento è scaduta. Tre ore dopo la creazione iniziale del completamento della transazione, Stripe fa scadere automaticamente i PaymentIntents che non vengono autorizzati con successo. |
| `payment_method_not_available`           | Afterpay ha riscontrato un errore relativo al servizio e non è in grado di completare la richiesta. Riprova più tardi.                                                                                                                                                                                               |
| `amount_too_small`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |
| `amount_too_large`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |

## See also

- [Ulteriori informazioni su Afterpay](https://docs.stripe.com/payments/afterpay-clearpay.md)
- [Completamento del pagamento](https://docs.stripe.com/checkout/fulfillment.md)
- [Personalizzazione di Checkout](https://docs.stripe.com/payments/checkout/customization.md)

# API Checkout Sessions

> This is a API Checkout Sessions for when payment-ui is elements and api-integration is checkout. View the full page at https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment?payment-ui=elements&api-integration=checkout.

Per determinare quale API soddisfa le esigenze della tua azienda, consulta la [Guida al confronto](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilizza [Payment Element](https://docs.stripe.com/payments/payment-element.md) per integrare un modulo di pagamento Stripe personalizzato nel tuo sito web o nella tua applicazione e offrire metodi di pagamento ai clienti. Per configurazioni e personalizzazioni avanzate, consulta la guida all’integrazione [Accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md).

## Determina la compatibilità

**Area geografica del cliente**: Australia, Canada, New Zealand, UK, US

**Valute accettate**: `aud, cad, nzd, gbp, usd`

**Valute di pagamento**: `aud, cad, nzd, gbp, usd`

**Metodi di pagamento**: Yes

**Modalità di configurazione**: No

**Modalità di abbonamento**: No

Per supportare i pagamenti Afterpay, una sessione di Checkout deve soddisfare tutte le seguenti condizioni:

- Puoi usare solo le voci riga una tantum (i piani di *abbonamento* (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) ricorrenti non sono supportati).
- I *prezzi* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) devono essere indicati nella valuta nazionale.

## Configura il server [Lato server]

Utilizza le librerie ufficiali di Stripe per accedere all’API dalla tua applicazione.

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

## Crea una sessione di checkout [Lato server]

Aggiungi sul server un endpoint che crei una [sessione di Checkout](https://docs.stripe.com/api/checkout/sessions/create.md) della transazione e restituisca la chiave privata [client](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret) al front-end. Una sessione di Checkout rappresenta la sessione del cliente che paga acquisti o abbonamenti una tantum. Le Sessioni di Checkout scadono 24 ore dopo la creazione.

Consigliamo di utilizzare [metodi di pagamento dinamici](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) per mostrare dinamicamente a ciascun cliente i metodi di pagamento idonei più pertinenti per massimizzare la conversione. Puoi anche [elencare manualmente i metodi di pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md#listing-payment-methods-manually), che disabilitano i metodi di pagamento dinamici.

#### Gestire le modalità di pagamento dalla Dashboard

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 1099,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',
    ui_mode: 'elements',
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

#### Elencare manualmente le modalità di pagamento

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 1099,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',
    ui_mode: 'elements',
    payment_method_types: ['afterpay_clearpay'],
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

## Configura il front-end [Lato client]

#### HTML + JS

Includi lo script Stripe.js nella tua pagina di checkout aggiungendolo al valore `head` del tuo file HTML. Carica sempre Stripe.js direttamente da js.stripe.com per garantire la conformità PCI. Non includere lo script in un pacchetto e non utilizzarne una copia in self-hosting.

Assicurati di utilizzare la versione più recente di Stripe includendo il seguente tag nello script `<script src=“https://js.stripe.com/dahlia/stripe.js”></script>`. Ulteriori informazioni sul [controllo delle versioni di Stripe.js](https://docs.stripe.com/sdks/stripejs-versioning.md).

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

> Stripe fornisce un pacchetto npm che puoi utilizzare per caricare Stripe.js come modulo. Consulta il [progetto su GitHub](https://github.com/stripe/stripe-js). È richiesta la versione [7.0.0](https://www.npmjs.com/package/%40stripe/stripe-js/v/7.0.0) o versioni successive.

Inizializza Stripe.js

```js
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe(
  '<<YOUR_PUBLISHABLE_KEY>>',
);
```

#### React

Installa [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) e il [caricatore Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) dal registro pubblico npm. È necessaria almeno la versione 5.0.0 per React Stripe.js e la versione 8.0.0 per il caricatore Stripe.js.

```bash
npm install --save @stripe/react-stripe-js@^5.0.0 @stripe/stripe-js@^8.0.0
```

Inizializza un’istanza `stripe` sul front-end con la tua chiave pubblicabile.

```javascript
import {loadStripe} from '@stripe/stripe-js';
const stripe = loadStripe("<<YOUR_PUBLISHABLE_KEY>>");
```

## Inizializza Checkout [Lato client]

#### HTML + JS

Chiama [initCheckoutElementsSdk](https://docs.stripe.com/js/custom_checkout/init), specificando `clientSecret`.

`initCheckoutElementsSdk` restituisce un oggetto [Checkout](https://docs.stripe.com/js/custom_checkout) che contiene i dati della sessione di checkout e i metodi per aggiornarla.

Leggi `total` e `lineItems` da [actions.getSession()](https://docs.stripe.com/js/custom_checkout/session), e mostrali nella tua interfaccia utente. Ciò consente di attivare nuove funzioni con modifiche minime al codice. Ad esempio, l’aggiunta dei [prezzi in valuta manuali](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) non richiede alcuna modifica all’interfaccia utente se mostri `total`.

```html
<div id="checkout-container"></div>
```

```javascript
const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const session = loadActionsResult.actions.getSession();
  const checkoutContainer = document.getElementById('checkout-container');

  checkoutContainer.append(JSON.stringify(session.lineItems, null, 2));
  checkoutContainer.append(document.createElement('br'));
  checkoutContainer.append(`Total: ${session.total.total.amount}`);
}
```

#### React

Includi la tua richiesta di registrazione con il componente [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider), specificando `clientSecret` e l’istanza `stripe`.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const App = () => {
  return (
    <CheckoutElementsProvider
      stripe={stripe}options={{clientSecret}}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

Accedi all’oggetto [Checkout](https://docs.stripe.com/js/custom_checkout) nel componente del tuo modulo di checkout utilizzando l’hook `useCheckoutElements()`. L’oggetto `Checkout` contiene i dati della Checkout Session e i metodi per aggiornarla.

Leggi `total` and `lineItems` dall’oggetto `Checkout` e visualizzali nell’interfaccia utente. In questo modo puoi abilitare le funzioni con modifiche minime al codice. Ad esempio, l’aggiunta di [prezzi di valuta manuali](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) non richiede modifiche all’interfaccia utente se visualizzi `total`.

```jsx
import React from 'react';
import {useCheckoutElements} from '@stripe/react-stripe-js/checkout';

const CheckoutForm = () => {const checkoutState = useCheckoutElements();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>{JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
    </form>
  );
};
```

## Raccogli l'email del cliente [Lato client]

#### HTML + JS

Al completamento di una sessione di Checkout, devi fornire un’email cliente valida.

Queste istruzioni creano un inserimento email e utilizzano [updateEmail](https://docs.stripe.com/js/custom_checkout/update_email) dall’oggetto `Checkout`.

In alternativa:

- Specifica [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [customer_account](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (per i clienti rappresentati come oggetti `Account` configurati dal cliente) o [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (per i clienti rappresentati come oggetti `customer`) durante la creazione della sessione di Checkout. Stripe convalida le email fornite in questo modo.
- Inserisci un’email che hai già convalidato su [Checkout.confirm](https://docs.stripe.com/js/custom_checkout/confirm).

```html
<input type="text" id="email" />
<div id="email-errors"></div>
```

```javascript
const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const emailInput = document.getElementById('email');
  const emailErrors = document.getElementById('email-errors');

  emailInput.addEventListener('input', () => {
    // Clear any validation errors
    emailErrors.textContent = '';
  });

  emailInput.addEventListener('blur', () => {
    const newEmail = emailInput.value;actions.updateEmail(newEmail).then((result) => {
      if (result.error) {
        emailErrors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Al completamento di una sessione di Checkout, devi fornire un’email cliente valida.

Queste istruzioni creano un inserimento email e utilizzano [updateEmail](https://docs.stripe.com/js/react_stripe_js/checkout/update_email) dall’oggetto `Checkout`.

In alternativa:

- Specifica [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [customer_account](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (per i clienti rappresentati come oggetti `Account` configurati dal cliente) o [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (per i clienti rappresentati come oggetti `customer`) durante la creazione della sessione di Checkout. Stripe convalida le email fornite in questo modo.
- Inserisci un’email che hai già convalidato al momento della [conferma](https://docs.stripe.com/js/react_stripe_js/checkout/confirm).

```jsx
import React from 'react';
import {useCheckoutElements} from '@stripe/react-stripe-js/checkout';

const EmailInput = () => {
  const checkoutState = useCheckoutElements();
  const [email, setEmail] = React.useState('');
  const [error, setError] = React.useState(null);

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  const handleBlur = () => {checkoutState.checkout.updateEmail(email).then((result) => {
      if (result.type === 'error') {
        setError(result.error);
      }
    })
  };

  const handleChange = (e) => {
    setError(null);
    setEmail(e.target.value);
  };

  return (
    <div>
      <label htmlFor="checkout-form-email">Email</label>
      <input
        id="checkout-form-email"
        type="email"
        value={email}
        onChange={handleChange}
        onBlur={handleBlur}
      />
      {error && <div>{error.message}</div>}
    </div>
  );
};

export default EmailInput;
```

## Raccogliere i dati di pagamento [Lato client]

Raccogli i dati di pagamento sul client con [Payment Element](https://docs.stripe.com/payments/payment-element.md). Payment Element è un componente di interfaccia utente preintegrato che semplifica la raccolta dei dati di pagamento per vari metodi di pagamento.

Payment Element contiene un iframe che invia a Stripe le informazioni sul pagamento in modo sicuro tramite una connessione HTTPS. Evita di inserire Payment Element all’interno di un altro iframe, perché alcuni metodi di pagamento richiedono il reindirizzamento a un’altra pagina per la conferma del pagamento.

Se scegli di utilizzare un iframe e desideri accettare Apple Pay o Google Pay, l’iframe deve avere l’attributo [allow](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) impostato su `"payment *"`.

Affinché l’integrazione funzioni, l’indirizzo della pagina di checkout deve iniziare con `https://` rather anziché con `http://` for. Puoi testare l’integrazione senza usare HTTPS, ma ricorda di [abilitarlo](https://docs.stripe.com/security/guide.md#tls) quando sarà tutto pronto per accettare i pagamenti in modalità live.

#### HTML + JS

Innanzitutto, crea un elemento DOM del contenitore per montare [Payment Element](https://docs.stripe.com/payments/payment-element.md). Poi crea un’istanza di `Payment Element` utilizzando [checkout.createPaymentElement](https://docs.stripe.com/js/custom_checkout/create_payment_element) e montala chiamando [element.mount](https://docs.stripe.com/js/element/mount), fornendo un selettore CSS o l’elemento DOM del contenitore.

```html
<div id="payment-element"></div>
```

```javascript
const paymentElement = checkout.createPaymentElement();
paymentElement.mount('#payment-element');
```

Consulta la [documentazione Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) per visualizzare le opzioni supportate.

Puoi [personalizzare l’aspetto](https://docs.stripe.com/payments/checkout/customization/appearance.md) di tutti gli elementi specificando [elementsOptions.appearance](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions-appearance) durante l’inizializzazione di Checkout nel front-end.

#### React

Monta il componente [Payment Element](https://docs.stripe.com/payments/payment-element.md) all’interno del [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

```jsx
import React from 'react';import {PaymentElement, useCheckoutElements} from '@stripe/react-stripe-js/checkout';

const CheckoutForm = () => {
  const checkoutState = useCheckoutElements();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>

      {JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
<PaymentElement options={{layout: 'accordion'}}/>
    </form>
  );
};

export default CheckoutForm;
```

Consulta la [documentazione Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) per visualizzare le opzioni supportate.

Puoi [personalizzare l’aspetto](https://docs.stripe.com/payments/checkout/customization/appearance.md) di tutti gli Elements specificando [elementsOptions.appearance](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions-appearance) in [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

## Invia il pagamento: [Lato client]

#### HTML + JS

Visualizza un pulsante **Paga** che le chiamate [confermano](https://docs.stripe.com/js/custom_checkout/confirm) dall’istanza di `Checkout` per inviare il pagamento.

```html
<button id="pay-button">Pay</button>
<div id="confirm-errors"></div>
```

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});

checkout.on('change', (session) => {
  document.getElementById('pay-button').disabled = !session.canConfirm;
});

const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const button = document.getElementById('pay-button');
  const errors = document.getElementById('confirm-errors');
  button.addEventListener('click', () => {
    // Clear any validation errors
    errors.textContent = '';

    actions.confirm().then((result) => {
      if (result.type === 'error') {
        errors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Visualizza un pulsante **Paga** che richiama [conferma](https://docs.stripe.com/js/custom_checkout/confirm) da [useCheckoutElements](https://docs.stripe.com/js/react_stripe_js/checkout/use_checkout_elements) per inviare il pagamento.

```jsx
import React from 'react';
import {useCheckoutElements} from '@stripe/react-stripe-js/checkout';

const PayButton = () => {
  const checkoutState = useCheckoutElements();
  const [loading, setLoading] = React.useState(false);
  const [error, setError] = React.useState(null);

  if (checkoutState.type !== "success") {
    return null;
  }

  const handleClick = () => {
    setLoading(true);checkoutState.checkout.confirm().then((result) => {
      if (result.type === 'error') {
        setError(result.error)
      }
      setLoading(false);
    })
  };

  return (
    <div>
      <button disabled={!checkoutState.checkout.canConfirm || loading} onClick={handleClick}>
        Pay
      </button>
      {error && <div>{error.message}</div>}
    </div>
  )
};

export default PayButton;
```

## Testare l'integrazione

Per testare la tua integrazione, scegli il metodo di pagamento e tocca **Paga**. In una *sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), verrai reindirizzato a una pagina di pagamento di test dove potrai approvare o rifiutare il pagamento.

In modalità live, toccando **Paga** verrai reindirizzato al sito web di Afterpay, senza potere approvare o rifiutare il pagamento con Afterpay.


# API Payment Intents

> This is a API Payment Intents for when payment-ui is elements and api-integration is paymentintents. View the full page at https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment?payment-ui=elements&api-integration=paymentintents.

Per determinare quale API soddisfa le esigenze della tua azienda, consulta la [Guida al confronto](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilizza [Payment Element](https://docs.stripe.com/payments/payment-element.md) per integrare un modulo di pagamento Stripe personalizzato nel tuo sito web o nella tua applicazione e offrire metodi di pagamento ai clienti. Per configurazioni e personalizzazioni avanzate, consulta la guida all’integrazione [Accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md).

## Configurare Stripe [Lato server]

Per iniziare, [crea un account Stripe](https://dashboard.stripe.com/register).

Utilizza le nostre librerie ufficiali per accedere all’API Stripe dalla tua applicazione:

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

## Raccogliere i dati di pagamento [Lato client]

A questo punto è tutto pronto per acquisire i dati di pagamento sul client con Payment Element. Payment Element è un componente di interfaccia utente preintegrato che semplifica l’acquisizione dei dati di pagamento per vari metodi di pagamento.

Payment Element contiene un iframe che invia a Stripe le informazioni sul pagamento in modo sicuro tramite una connessione HTTPS. Evita di inserire Payment Element all’interno di un altro iframe, perché alcuni metodi di pagamento richiedono il reindirizzamento a un’altra pagina per la conferma del pagamento.

Affinché l’integrazione funzioni, l’indirizzo della pagina di pagamento deve iniziare con `https://` anziché con `http://`. Puoi testare l’integrazione senza usare HTTPS, ma ricorda di [abilitarlo](https://docs.stripe.com/security/guide.md#tls) quando sarà tutto pronto per accettare i pagamenti in modalità live.

#### HTML + JS

### Configurare Stripe. js

Payment Element è automaticamente disponibile come funzione di Stripe.js. Includi lo script Stripe.js nella tua pagina di pagamento aggiungendolo all’oggetto `head` del tuo file HTML. Carica sempre Stripe.js direttamente da js.stripe.com per mantenere la conformità alle norme PCI. Non includere lo script in un pacchetto e non ospitarne una copia personale.

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Crea un’istanza di Stripe con il seguente JavaScript nella pagina di pagamento:

```javascript
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

### Aggiungi Payment Element alla pagina di pagamento

Il componente Payment Element deve avere uno spazio dedicato nella pagina di pagamento. Crea un nodo DOM (contenitore) vuoto con ID univoco nel modulo di pagamento:

```html
<form id="payment-form">
  <div id="payment-element">
    <!-- Elements will create form elements here -->
  </div>
  <button id="submit">Submit</button>
  <div id="error-message">
    <!-- Display error message to your customers here -->
  </div>
</form>
```

#### Controllare i metodi di pagamento dalla Dashboard

Una volta caricato il modulo sopra menzionato, crea un’istanza di Elements con i parametri `mode`, `amount` e `currency`. Questi valori determinano i metodi di pagamento visualizzati dal cliente. Per specificare un nuovo metodo di pagamento nel tuo modulo, assicurati di abilitarlo nella [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'usd',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

#### Elencare manualmente i metodi di pagamento

Per elencare manualmente i metodi di pagamento che desideri siano disponibili, aggiungili a`paymentMethodTypes`.

Quindi crea un’istanza di Payment Element e integrala nel nodo DOM del contenitore.

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'usd',
  paymentMethodTypes: ['afterpay_clearpay'],
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

#### React

### Configurare Stripe. js

Installa [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) e il [caricatore Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) dal registro di sistema pubblico npm.

```bash
npm install --save @stripe/react-stripe-js @stripe/stripe-js
```

### Aggiungi e configura il provider Elements alla pagina di pagamento

Per utilizzare il componente Payment Element, includi il componente della pagina di pagamento in un [provider Elements](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider). Chiama `loadStripe` con la chiave pubblicabile e fornisci il parametro `Promise` restituito al provider `Elements`.

#### Controllare i metodi di pagamento dalla Dashboard

Il provider `Elements` accetta anche i parametri `mode`, `amount` e `currency`. Questi valori determinano i metodi di pagamento visualizzati dal cliente. Per specificare un nuovo metodo di pagamento nel tuo modulo, assicurati di abilitarlo nella [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'usd',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

#### Elencare manualmente i metodi di pagamento

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'usd',
    paymentMethodTypes: ['afterpay_clearpay'],
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

### Aggiungere Payment Element

Utilizza il componente `PaymentElement` per creare il modulo.

```jsx
import React from 'react';
import {PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  return (
    <form><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

Puoi personalizzare il componente Payment Element perché si accordi al design del tuo sito specificando l’[oggetto appearance](https://docs.stripe.com/elements/appearance-api.md) in `options` al momento della creazione del provider `Elements`.

### Raccogli indirizzi

By default, the Payment Element only collects the necessary billing address details. Some behavior, such as [calculating tax](https://docs.stripe.com/api/tax/calculations/create.md) or entering shipping details, requires your customer’s full address. You can:

- Utilizza [Address Element](https://docs.stripe.com/elements/address-element.md) per sfruttare le funzioni di completamento automatico e localizzazione per raccogliere l’indirizzo completo dei tuoi clienti. Ciò contribuisce a garantire il calcolo più accurato delle imposte.
- Raccogli i dettagli dell’indirizzo utilizzando il tuo modulo personalizzato.

## Creare un PaymentIntent [Lato server]

> #### Eseguire la logica aziendale personalizzata immediatamente prima della conferma del pagamento
> 
> Vai alla [fase 5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) della guida ai pagamenti per eseguire la tua logica aziendale personalizzata immediatamente prima della conferma del pagamento. Altrimenti, segui i passaggi riportati di seguito per un’integrazione più semplice, che utilizza `stripe.confirmPayment` sul client per confermare il pagamento e gestire eventuali azioni successive.

#### Controllare i metodi di pagamento dalla Dashboard

Quando il cliente invia il modulo di pagamento, utilizza 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) per facilitare il processo di conferma e pagamento. Crea sul tuo server un PaymentIntent con i parametri `amount` e `currency` abilitati. Decidi sempre quanto addebitare sul lato server, che è un ambiente sicuro, anziché sul lato client. In questo modo impedisci ai client malintenzionati di scegliere un proprio prezzo.

Il `PaymentIntent` include una % glossary term=“payment-intent-secret” %}chiave privata client**. Restituisci questo valore al tuo client affinché Stripe.js lo utilizzi per completare la procedura di pagamento in modo sicuro.

#### Account v2

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the customer's Account ID.
    customer_account: "{{CUSTOMER_ACCOUNT_ID}}",
    amount: 1099,
    currency: 'usd',
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Clienti v1

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'usd',
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Elencare manualmente i metodi di pagamento

Quando il cliente invia il modulo di pagamento, utilizza 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) per facilitare la procedura di conferma e pagamento. Crea sul tuo server un PaymentIntent con `amount`, `currency` e uno o più metodi di pagamento utilizzando `payment_method_types`. Decidi sempre quanto addebitare sul lato server, che è un ambiente sicuro, anziché sul lato client. In questo modo impedisci ai client malintenzionati di scegliere un proprio prezzo.

Il PaymentIntent include una *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)). Restituisci questo valore al tuo client affinché Stripe.js lo utilizzi per completare la procedura di pagamento in modo sicuro.

#### Account v2

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the customer's Account ID.
    customer_account: customer_account.id,
    amount: 1099,
    currency: 'usd',
    payment_method_types: ['afterpay_clearpay'],
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Clienti v1

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'usd',
    payment_method_types: ['afterpay_clearpay'],
  })
  {client_secret: intent.client_secret}.to_json
end
```

## Inviare il pagamento a Stripe [Lato client]

Utilizza [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) per completare il pagamento utilizzando i dettagli di Payment Element.

Fornisci un [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) a questa funzione per indicare dove Stripe deve reindirizzare l’utente dopo il completamento del pagamento. L’utente può essere dapprima reindirizzato su un sito intermedio, come una pagina di autorizzazione della banca, prima di essere reindirizzato al `return_url`. In caso di esito positivo, i pagamenti con carta vengono immediatamente reindirizzati al `return_url`.

Se vuoi impedire il reindirizzamento per i pagamenti con carta una volta completato il pagamento, puoi impostare il [reindirizzamento](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) su `if_required`. In questo modo vengono reindirizzati solo i clienti che utilizzano metodi di pagamento basati sul reindirizzamento.

#### HTML + JS

```javascript

const form = document.getElementById('payment-form');
const submitBtn = document.getElementById('submit');

const handleError = (error) => {
  const messageContainer = document.querySelector('#error-message');
  messageContainer.textContent = error.message;
  submitBtn.disabled = false;
}

form.addEventListener('submit', async (event) => {
  // We don't want to let default form submission happen here,
  // which would refresh the page.
  event.preventDefault();

  // Prevent multiple form submissions
  if (submitBtn.disabled) {
    return;
  }

  // Disable form submission while loading
  submitBtn.disabled = true;

  // Trigger form validation and wallet collection
  const {error: submitError} = await elements.submit();
  if (submitError) {
    handleError(submitError);
    return;
  }

  // Create the PaymentIntent and obtain clientSecret
  const res = await fetch("/create-intent", {
    method: "POST",
  });

  const {client_secret: clientSecret} = await res.json();

  // Confirm the PaymentIntent using the details collected by the Payment Element
  const {error} = await stripe.confirmPayment({
    elements,
    clientSecret,
    confirmParams: {
      return_url: 'https://example.com/order/123/complete',
    },
  });

  if (error) {
    // This point is only reached if there's an immediate error when
    // confirming the payment. Show the error to your customer (for example, payment details incomplete)
    handleError(error);
  } else {
    // Your customer is redirected to your `return_url`. For some payment
    // methods like iDEAL, your customer is redirected to an intermediate
    // site first to authorize the payment, then redirected to the `return_url`.
  }
});

```

#### React

```jsx
import React, {useState} from 'react';
import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js';

export default function CheckoutForm() {
  const stripe = useStripe();
  const elements = useElements();

  const [errorMessage, setErrorMessage] = useState();
  const [loading, setLoading] = useState(false);

  const handleError = (error) => {
    setLoading(false);
    setErrorMessage(error.message);
  }

  const handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    if (!stripe) {
      // Stripe.js hasn't yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }

    setLoading(true);

    // Trigger form validation and wallet collection
    const {error: submitError} = await elements.submit();
    if (submitError) {
      handleError(submitError);
      return;
    }

    // Create the PaymentIntent and obtain clientSecret
    const res = await fetch("/create-intent", {
      method: "POST",
    });

    const {client_secret: clientSecret} = await res.json();

    // Confirm the PaymentIntent using the details collected by the Payment Element
    const {error} = await stripe.confirmPayment({
      elements,
      clientSecret,
      confirmParams: {
        return_url: 'https://example.com/order/123/complete',
      },
    });

    if (error) {
      // This point is only reached if there's an immediate error when
      // confirming the payment. Show the error to your customer (for example, payment details incomplete)
      handleError(error);
    } else {
      // Your customer is redirected to your `return_url`. For some payment
      // methods like iDEAL, your customer is redirected to an intermediate
      // site first to authorize the payment, then redirected to the `return_url`.
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button type="submit" disabled={!stripe || loading}>
        Submit Payment
      </button>
      {errorMessage && <div>{errorMessage}</div>}
    </form>
  );
}
```

## Optional: 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 la Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizzato o una soluzione partner per ricevere questi eventi ed eseguire azioni come l’invio della 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 un callback dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione del callback e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente anche di accettare metodi di pagamento diversi in futuro. Ulteriori informazioni sulle [differenze tra tutti i metodi di pagamento supportati](https://stripe.com/payments/payment-methods-guide).

- **Gestisci gli eventi manualmente nella dashboard**

  Utilizza la dashboard per [visualizzare i pagamenti di test nella dashboard](https://dashboard.stripe.com/test/payments), inviare le ricevute tramite email, gestire i bonifici o ritentare i pagamenti non riusciti.

- **Crea un webhook personalizzato**

  [Crea un gestore webhook personalizzato](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) per rilevare gli eventi e creare flussi di pagamento asincroni personalizzati. Esegui il test e il debug in locale dell’integrazione webhook con la CLI di Stripe.

- **Integra un’app preimpostata**

  Gestisci eventi comuni dell’attività, come l’[automazione](https://stripe.partners/?f_category=automation), il [marketing e i saldi](https://stripe.partners/?f_category=marketing-and-sales), integrando una richiesta di registrazione del partner.

## Optional: Separare l'autorizzazione dall'acquisizione

Puoi separare l’autorizzazione dall’acquisizione per creare un addebito immediatamente, ma acquisire i fondi in un secondo momento. Stripe annulla il PaymentIntent e invia un evento [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled) se il pagamento non viene acquisito durante la finestra di 7 giorni.

Se sei sicuro di non poter acquisire il pagamento, ti consigliamo di [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) anziché attendere che trascorrano i 7 giorni.

### Indicare a Stripe di eseguire solo l’autorizzazione

Per indicare che vuoi separare l’autorizzazione dall’acquisizione, imposta [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) su `manual` quando crei il PaymentIntent. Il parametro indica a Stripe di limitarsi ad autorizzare l’importo sul conto Afterpay del cliente.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d confirm=true \
  -d currency=usd \
  -d "payment_method_types[]=afterpay_clearpay" \
  -d "payment_method_data[type]=payment_method" \
  -d capture_method=manual \
  --data-urlencode "return_url=https://www.example.com/checkout/done"
```

### Acquisire i fondi

Dopo l’avvenuta autorizzazione, lo [stato del PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) diventa `requires_capture`. Per acquisire i fondi autorizzati, crea una richiesta di [acquisizione](https://docs.stripe.com/api/payment_intents/capture.md) del PaymentIntent.

```curl
curl -X POST https://api.stripe.com/v1/payment_intents/{PAYMENT_INTENT_ID}/capture \
  -u "<<YOUR_SECRET_KEY>>:"
```

Stripe acquisisce l’importo totale autorizzato per impostazione predefinita. Puoi anche specificare che `amount_to_capture` sia minore o uguale al totale.

### (Facoltativo) Annullare l’autorizzazione

Per annullare un’autorizzazione, puoi [annullare il PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md).

## Testare l'integrazione

Per testare la tua integrazione, scegli il metodo di pagamento e tocca **Paga**. In una *sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), verrai reindirizzato a una pagina di pagamento di test dove potrai approvare o rifiutare il pagamento.

In modalità live, toccando **Paga** verrai reindirizzato al sito web di Afterpay, senza potere approvare o rifiutare il pagamento con Afterpay.

## Codici di errore

La tabella seguente illustra in dettaglio i codici di errore comuni e le azioni consigliate:

| Codice di errore                                          | Azione consigliata                                                                                                                                                                                                                                                                                                                                                                                                          |
| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_invalid_currency`                         | Inserisci una valuta supportata.                                                                                                                                                                                                                                                                                                                                                                                            |
| `missing_required_parameter`                              | Controlla il messaggio di errore per sapere di più sul parametro richiesto.                                                                                                                                                                                                                                                                                                                                                 |
| `payment_intent_payment_attempt_failed`                   | Questo codice può essere visualizzato nel campo [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) di un PaymentIntent. Consulta il messaggio di errore per informazioni dettagliate sul motivo dell’errore e suggerimenti su come gestirlo.                                                                                                    |
| `payment_intent_authentication_failure`                   | Questo codice può apparire nella sezione [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) campo di un PaymentIntent. Controlla se il messaggio di errore ha un motivo dettagliato dell’errore e suggerimenti sulla gestione degli errori. Questo errore si verifica quando si attiva manualmente un errore durante il test dell’integrazione. |
| `payment_intent_redirect_confirmation_without_return_url` | Specifica un `return_url` quando confermi un PaymentIntent.                                                                                                                                                                                                                                                                                                                                                                 |


> Il contenuto di questa sezione fa riferimento a un prodotto *precedente* (Technology that's no longer recommended). Per conoscere il percorso di integrazione più recente, consulta la guida [Accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md). Sebbene Stripe supporti ancora questo prodotto, qualora il prodotto dovesse diventare obsoleto questo tipo di assistenza potrebbe terminare.

Gli utenti Stripe possono usare l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md) con un percorso di integrazione unico per creare pagamenti utilizzando qualsiasi modalità supportata per accettare pagamenti [Afterpay](https://www.afterpay.com/) da clienti nei seguenti Paesi:

- Australia
- Canada
- Nuova Zelanda
- Regno Unito
- Stati Uniti

Afterpay è un metodo di pagamento [monouso](https://docs.stripe.com/payments/payment-methods.md#usage) con [notifica immediata](https://docs.stripe.com/payments/payment-methods.md#payment-notification) che richiede ai clienti di [autenticare](https://docs.stripe.com/payments/payment-methods.md#customer-actions) il pagamento. I clienti vengono reindirizzati al sito Afterpay dove possono accettare i termini di un piano di rateizzazione. Quando il cliente accetta i termini, i fondi vengono garantiti e trasferiti sul tuo account Stripe. Il cliente ripaga direttamente Afterpay nel tempo.

> Prima di avviare l’integrazione, assicurati che il tuo account sia idoneo per Afterpay accedendo alle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods).

## Configurare Stripe [Lato server]

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

Utilizza le nostre librerie ufficiali per accedere all’API Stripe dalla tua applicazione:

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

## Creare un PaymentIntent [Lato server]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) è un oggetto che rappresenta la tua intenzione di riscuotere un pagamento da un cliente e traccia il ciclo di vita del processo di pagamento in ogni sua fase. Innanzitutto crea un `PaymentIntent` sul tuo server e specifica l’importo da riscuotere e la valuta. Se hai già un’integrazione che utilizza l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), aggiungi `afterpay_clearpay` all’elenco dei [tipi di metodi di pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) per il tuo `PaymentIntent`.

Puoi gestire i metodi di pagamento dalla [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe determina il reindirizzamento ai metodi di pagamento idonei in base a fattori quali l’importo della transazione, la valuta e il flusso di pagamento. Nell’esempio che segue viene utilizzato l’attributo [automatic_payment_methods](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-automatic_payment_methods-enabled), ma puoi elencare `afterpay_clearpay` con i [tipi di metodi di pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types). Nell’ultima versione dell’API, specificare il parametro `automatic_payment_methods` è facoltativo perché Stripe ne abilita la funzionalità per impostazione predefinita. Indipendentemente dall’opzione scelta, assicurati di abilitare Afterpay Clearpay nella [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true" \
  -d "shipping[name]=Jenny Rosen" \
  -d "shipping[address][line1]=1234 Main Street" \
  -d "shipping[address][city]=San Francisco" \
  -d "shipping[address][state]=CA" \
  -d "shipping[address][country]=US" \
  -d "shipping[address][postal_code]=94111"
```

### Recuperare la chiave privata client

L’oggetto PaymentIntent contiene una *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)), che il lato client usa per completare la procedura di pagamento in modo sicuro. Per specificare la chiave privata sul lato client, puoi utilizzare approcci diversi.

#### Applicazione a pagina singola

Recupera la chiave privata client dall’endpoint sul server utilizzando la funzione `fetch`del browser. Questo approccio è più adatto quando il lato client è un’applicazione con un’unica pagina, in particolare creata con un framework front-end moderno come React. Crea l’endpoint server che invia la chiave privata client:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Quindi recupera la chiave privata client con JavaScript sul lato client:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Rendering lato server

Trasmetti la chiave privata client al client dal server. Questo approccio è più adatto se l’applicazione genera contenuti statici sul server prima di inviarli al browser.

Aggiungi la [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) nel modulo di pagamento. Nel codice lato server, recupera la chiave privata client da PaymentIntent:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <div id="payment-element">
    <!-- placeholder for Elements -->
  </div>
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

### Migliora i tassi di successo dei pagamenti con ulteriori dettagli

Facoltativamente, trasmetti i dettagli di [spedizione](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-shipping) per migliorare i tassi di conversione. In questa integrazione, trasmetti i dettagli di spedizione dal cliente dopo che il tuo cliente ha selezionato un metodo di pagamento

Se invii un indirizzo di spedizione, deve includere valori validi per `line1`, `city`, `state`, `postal_code`, e `country`.

### Altre opzioni delle modalità di pagamento

Puoi specificare un parametro `reference` facoltativo nelle [opzioni relative al metodo di pagamento](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) del tuo `PaymentIntent` puoi specificare un parametro di riferimento facoltativo che definisce un identificatore interno dell’ordine per il pagamento. Sebbene questo identificatore non sia solitamente visibile né all’attività né al consumatore, il team di assistenza interno di Afterpay può accedervi in caso di richieste di assistenza manuale. L’identificatore è limitato a 128 caratteri e può contenere solo lettere, cifre, trattini bassi, barre rovesciate e trattini.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \
  // Shipping address is optional but recommended to pass in.
  -d "shipping[name]"="Jenny Rosen" \
  -d "shipping[address][line1]"="1234 Main Street" \
  -d "shipping[address][city]"="San Francisco" \
  -d "shipping[address][state]"="CA" \
  -d "shipping[address][country]"="US" \
  -d "shipping[address][postal_code]"=94111 \-d "payment_method_options[afterpay_clearpay][reference]"="order_123"
```

## Inviare il pagamento a Stripe [Lato client]

In questo passaggio, completi i pagamenti Afterpay sul client con [Stripe.js](https://docs.stripe.com/payments/elements.md).

### Configurare Stripe.js

Quando un cliente fa clic per pagare con Afterpay, ti consigliamo di utilizzare Stripe.js per inviare il pagamento a Stripe. Stripe.js è la nostra libreria JavaScript di base per creare i flussi di pagamento. Gestisce automaticamente le operazioni complesse, come il reindirizzamento descritto di seguito. Inoltre ti consente di estendere facilmente la tua integrazione ad altre modalità di pagamento in futuro. Per includere lo script di Stripe.js nella tua pagina di pagamenti, aggiungilo nell’intestazione del file HTML.

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Crea un’istanza di Stripe.js con il seguente JavaScript nella pagina di pagamento:

```javascript
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
var stripe = Stripe(
  '<<YOUR_PUBLISHABLE_KEY>>',
);
```

Anziché inviare tutto l’oggetto PaymentIntent al client, utilizza la [chiave privata client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) del [passaggio 2](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#web-create-payment-intent). Questa chiave è diversa dalle chiavi API che eseguono l’autenticazione delle richieste API Stripe.

Gestisci la chiave privata client con attenzione in quanto può effettuare l’addebito. Non devi registrarla, inserirla negli URL né mostrarla a nessuno se non al cliente.

Utilizza [stripe.confirmAfterpayClearpayPayment](https://docs.stripe.com/js/payment_intents/confirm_afterpay_clearpay_payment) per gestire il reindirizzamento dalla tua pagina e completare il pagamento. Aggiungi un [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) a questa funzione per specificare dove Stripe deve reindirizzare l’utente dopo il completamento del pagamento sull’applicazione mobile o il sito web di Afterpay.

```javascript
// Redirects away from the client
const {error} = await stripe.confirmAfterpayClearpayPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      billing_details: {
        email: 'jenny@rosen.com',
        name: 'Jenny Rosen',
        address: {
          line1: '1234 Main Street',
          city: 'San Francisco',
          state: 'CA',
          country: 'US',
          postal_code: '94111',
        },
      },
    },
    return_url: 'https://example.com/checkout/complete',
  }
);
if (error) {
  // Inform the customer that there was an error.
}
```

Quando il cliente invia un pagamento, Stripe lo reindirizza al `return_url` e include i seguenti parametri di ricerca dell’URL. La pagina di ritorno può utilizzarli per ottenere lo stato del PaymentIntent in modo da poter mostrare lo stato del pagamento al cliente.

Quando specifichi il parametro `return_url`, puoi anche aggiungere i tuoi parametri di ricerca da utilizzare nella pagina di ritorno.

| Parametro                      | Descrizione                                                                                                                                                                                                                                                                                                                                                                 |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent`               | Identificativo univoco per il `PaymentIntent`                                                                                                                                                                                                                                                                                                                               |
| `payment_intent_client_secret` | La [chiave privata client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) dell’oggetto `PaymentIntent`. Per le integrazioni per gli abbonamenti, questo client_secret è esposto anche nell’oggetto `Invoice` tramite [`confirmation_secret`](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) |

Quando il cliente viene reindirizzato al tuo sito, puoi utilizzare il `payment_intent_client_secret` per eseguire una query per il PaymentIntent e mostrare al cliente lo stato della transazione.

## Optional: Aggiungere voci riga al PaymentIntent

Se vuoi, puoi accettare i dati delle voci riga per fornire ulteriori segnali di rischio ad Afterpay. Questa funzione è attualmente in versione beta privata. Contattaci utilizzando il modulo presente su [assistenza Stripe](https://support.stripe.com) se desideri richiedere l’accesso.

## Optional: Separare l'autorizzazione dall'acquisizione

Anziché [separare l’autorizzazione dall’acquisizione per i pagamenti con carta](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md), Afterpay addebita al cliente la prima rata del pagamento al momento dell’autorizzazione. Poi hai fino a 13 giorni dopo l’autorizzazione per acquisire il resto del pagamento. Se non acquisisci il pagamento in questo intervallo di tempo, il cliente riceve un rimborso della prima rata e non gli vengono addebitate altre rate. In questi casi, Stripe annulla anche il PaymentIntent e invia un evento [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Se sai di non poter acquisire il pagamento, ti consigliamo di [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) anziché attendere che trascorrano i 13 giorni. Se annulli in modo proattivo il PaymentIntent, il cliente riceve immediatamente il rimborso della prima rata, evitando confusioni sugli addebiti sul suo estratto conto.

### Indicare a Stripe di eseguire solo l’autorizzazione

Per indicare che vuoi separare l’autorizzazione dall’acquisizione, imposta [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) su `manual` quando crei il PaymentIntent. Il parametro indica a Stripe di limitarsi ad autorizzare l’importo sul conto Afterpay del cliente.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \
  -d "capture_method"="manual" \
  -d "shipping[name]"="Jenny Rosen" \
  -d "shipping[address][line1]"="1234 Main Street" \
  -d "shipping[address][city]"="San Francisco" \
  -d "shipping[address][state]"="CA" \
  -d "shipping[address][country]"="US" \
  -d "shipping[address][postal_code]"=94111
```

In seguito alla concessione dell’autorizzazione, Stripe invia un evento [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Consulta la nostra [Guida agli eventi](https://docs.stripe.com/api/events.md) per saperne di più.

### Acquisire i fondi

Dopo l’avvenuta autorizzazione, lo [stato](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) PaymentIntent diventa `requires_capture`. Per acquisire i fondi autorizzati, effettua una richiesta di [acquisizione](https://docs.stripe.com/api/payment_intents/capture.md) del PaymentIntent. L’importo totale autorizzato viene acquisito per impostazione predefinita. Non puoi acquisire un importo superiore, ma puoi acquisire un importo inferiore.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/capture \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount_to_capture=750
```

### (Facoltativo) Annullare l’autorizzazione

Per annullare un’autorizzazione, puoi [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment).

## Optional: Gestire il reindirizzamento Afterpay manualmente

Per gestire i reindirizzamenti e i pagamenti Afterpay lato client con `confirmAfterpayClearpayPayment`, consigliamo di utilizzare Stripe.js. Utilizzando Stripe.js puoi estendere l’integrazione ad altri metodi di pagamento. Tuttavia, puoi anche reindirizzare manualmente i clienti al tuo server seguendo questi passaggi:

- Crea e conferma un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) di tipo `afterpay_clearpay`. Devi specificare la proprietà `payment_method_data.billing_details` richiesta da Afterpay. `payment_intent.shipping` è facoltativo, ma consigliato per migliorare i tassi di autenticazione. Se specifichi`payment_method_data`, Stripe crea un *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) e lo utilizza immediatamente con questo PaymentIntent.

  Una volta che il cliente ha completato il pagamento, devi anche specificare l’URL di reindirizzamento nel campo `return_url`. In questo URL puoi anche specificare i tuoi parametri di ricerca, che verranno inclusi nell’URL finale una volta completato il flusso di reindirizzamento.

  #### curl

  ```bash
  curl https://api.stripe.com/v1/payment_intents \
    -u <<YOUR_SECRET_KEY>>: \
    -d "amount"=1099 \
    -d "currency"="usd" \
    -d "confirm"="true" \
    -d "payment_method_types[]"="afterpay_clearpay" \
    -d "shipping[name]"="Jenny Rosen" \
    -d "shipping[address][line1]"="1234 Main Street" \
    -d "shipping[address][city]"="San Francisco" \
    -d "shipping[address][state]"="CA" \
    -d "shipping[address][country]"="US" \
    -d "shipping[address][postal_code]"=94111 \
    -d "payment_method_data[billing_details][name]"="Jenny Rosen" \
    -d "payment_method_data[billing_details][email]"="jenny@example.com" \
    -d "payment_method_data[billing_details][address][line1]"="1234 Main Street" \
    -d "payment_method_data[billing_details][address][city]"="San Francisco" \
    -d "payment_method_data[billing_details][address][state]"="CA" \
    -d "payment_method_data[billing_details][address][country]"="US" \
    -d "payment_method_data[billing_details][address][postal_code]"=94111 \
    -d "payment_method_data[type]"="afterpay_clearpay" \
    -d "return_url"="https://example.com/checkout/complete"
  ```

  Il `PaymentIntent` creato ha lo stato `requires_action` e il tipo per `next_action` è `redirect_to_url`.

  #### Json

  ```json
  {"status": "requires_action",
    "next_action": {
      "type": "redirect_to_url",
      "redirect_to_url": {
        "url": "https://hooks.stripe.com/...",
        "return_url": "https://example.com/checkout/complete"
      }
    },
    "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT",
    "object": "payment_intent",
    "amount": 1099,
    "client_secret": "pi_1G1sgdKi6xqXeNtkldRRE6HT_secret_h9B56ObhTN72fQiBAuzcVPb2E",
    "confirmation_method": "automatic",
    "created": 1579259303,
    "currency": "usd",
    "livemode": true,
    "charges": {
      "data": [],
      "object": "list",
      "has_more": false,
      "url": "/v1/charges?payment_intent=pi_1G1sgdKi6xqXeNtkldRRE6HT"
    },
    "payment_method_options": {
      "afterpay_clearpay": {}
    },
    "payment_method_types": [
      "afterpay_clearpay"
    ]
  }
  ```

- Reindirizza il cliente all’URL specificato nella proprietà `next_action.redirect_to_url.url` . Il codice esemplificativo indicato qui è approssimativo. La modalità di reindirizzamento potrebbe essere diversa nel tuo web framework.

  #### Ruby

  ```ruby
  if payment_intent.status == 'requires_action' && payment_intent.next_action.type == 'redirect_to_url'
    url = payment_intent.next_action.redirect_to_url.url
    redirect(url)
  end
  ```

Al termine della procedura di pagamento, il cliente viene indirizzato al `return_url` configurato nel passaggio 1. I parametri di query dell’URL `payment_intent` e `payment_intent_client_secret` sono inclusi e puoi specificare i tuoi come descritto sopra.

Ti consigliamo di [utilizzare i webhook](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) per confermare lo stato di un pagamento.

## Optional: 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 la Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizzato o una soluzione partner per ricevere questi eventi ed eseguire azioni come l’invio della 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 un callback dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione del callback e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente anche di accettare metodi di pagamento diversi in futuro. Ulteriori informazioni sulle [differenze tra tutti i metodi di pagamento supportati](https://stripe.com/payments/payment-methods-guide).

- **Gestisci gli eventi manualmente nella dashboard**

  Utilizza la dashboard per [visualizzare i pagamenti di test nella dashboard](https://dashboard.stripe.com/test/payments), inviare le ricevute tramite email, gestire i bonifici o ritentare i pagamenti non riusciti.

- **Crea un webhook personalizzato**

  [Crea un gestore webhook personalizzato](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) per rilevare gli eventi e creare flussi di pagamento asincroni personalizzati. Esegui il test e il debug in locale dell’integrazione webhook con la CLI di Stripe.

- **Integra un’app preimpostata**

  Gestisci eventi comuni dell’attività, come l’[automazione](https://stripe.partners/?f_category=automation), il [marketing e i saldi](https://stripe.partners/?f_category=marketing-and-sales), integrando una richiesta di registrazione del partner.

## Optional: Testare l'integrazione Afterpay

Testa la tua integrazione Afterpay con le tue chiavi API di test visualizzando la pagina di reindirizzamento. Puoi testare il caso di pagamento riuscito autenticando il pagamento sulla pagina di reindirizzamento. Il PaymentIntent passerà da `requires_action` a `succeeded`.

Per testare il caso in cui l’utente non riesce a effettuare l’autenticazione, usa le tue chiavi API di test e visualizza la pagina di reindirizzamento. In questa pagina, fai clic su **Interrompi pagamento di test**. Il PaymentIntent passerà da `requires_action` a `requires_payment_method`.

Per i PaymentIntent con [acquisizione manuale](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) in modalità di test, il PaymentIntent non acquisito scade automaticamente 10 minuti dopo che viene concessa l’autorizzazione.

## Optional: Visualizza i messaggi sulla modalità di pagamento sul tuo sito web

[Payment Method Messaging Element](https://docs.stripe.com/js/elements_object/create_element?type=paymentMethodMessaging) è un componente dell’interfaccia utente incorporabile che aiuta i clienti a sapere quali opzioni di pagamento a rate hanno al momento del pagamento direttamente dalle pagine del prodotto, del carrello o del pagamento.

Per aggiungere Payment Method Messaging Element al tuo sito web, consulta [Messaggi sul metodo di pagamento](https://docs.stripe.com/elements/payment-method-messaging.md).

## Pagamenti non riusciti

Afterpay decide se accettare o rifiutare una transazione in base a diversi fattori, ad esempio da quanto tempo l’acquirente utilizza Afterpay, l’importo in sospeso che il cliente deve rimborsare o il valore dell’ordine corrente.

Dato che i pagamenti Afterpay hanno un tasso di rifiuto più elevato rispetto a molti metodi di pagamento, dovresti sempre includere opzioni di pagamento aggiuntive nel tuo flusso di pagamento, come ad esempio `card`. In questi casi, il [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) viene scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) diventa automaticamente a `requires_payment_method`.

Per un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) Afterpay con stato `requires_action`, i clienti devono completare il pagamento entro tre ore dal reindirizzamento al sito Afterpay (ciò non riguarda i pagamenti rifiutati). In caso contrario, l’oggetto [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) verrà scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) passerà automaticamente a `requires_payment_method`

In questi casi, invita il cliente a riprovare con una diversa opzione di pagamento presente nel tuo flusso di completamento della transazione.

## Codici di errore

Questi sono i codici di errore più diffusi e le corrispondenti azioni consigliate:

| Codice di errore                         | Azione consigliata                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Un errore generico che indica che Afterpay Checkout non è andato a buon fine. Può trattarsi anche di un pagamento rifiutato che non viene visualizzato come codice di errore pagamento rifiutato.                                                                                                                    |
| `payment_method_provider_decline`        | Afterpay ha rifiutato il pagamento del cliente. Successivamente, il cliente dovrà contattare Afterpay per richiedere ulteriori informazioni.                                                                                                                                                                         |
| `payment_intent_payment_attempt_expired` | Il cliente non ha mai completato il pagamento sulla pagina di completamento della transazione di Afterpay e la sessione di pagamento è scaduta. Tre ore dopo la creazione iniziale del completamento della transazione, Stripe fa scadere automaticamente i PaymentIntents che non vengono autorizzati con successo. |
| `payment_method_not_available`           | Afterpay ha riscontrato un errore relativo al servizio e non è in grado di completare la richiesta. Riprova più tardi.                                                                                                                                                                                               |
| `amount_too_small`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |
| `amount_too_large`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |

# iOS

> This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment?payment-ui=mobile&platform=ios.

L’accettazione di Afterpay nella tua app consiste nella visualizzazione di una vista web con cui il cliente deve autenticare il proprio pagamento. Il cliente torna quindi alla tua app e tu puoi *verificare* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) immediatamente se il pagamento ha avuto esito positivo o negativo.

> Prima di avviare l’integrazione, assicurati che il tuo account sia idoneo per Afterpay accedendo alle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods).

## Configura 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 per iOS di Stripe](https://github.com/stripe/stripe-ios) è open source, [completamente documentato](https://stripe.dev/stripe-ios/index.html) e compatibile con le app che supportano iOS 13 o versioni successive.

#### Swift Package Manager

Per installare l’SDK, segui questi passaggi:

1. In Xcode, seleziona **File** > **Aggiungi dipendenze pacchetto…** e inserisci `https://github.com/stripe/stripe-ios-spm` come URL repository.
1. Seleziona il numero dell’ultima versione dalla nostra [pagina delle release](https://github.com/stripe/stripe-ios/releases).
1. Aggiungi il prodotto **StripePaymentsUI** al [target della tua app](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).

#### CocoaPods

1. Se non l’hai ancora fatto, installa la versione più recente di [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Se non hai un [Podfile](https://guides.cocoapods.org/syntax/podfile.html), esegui il seguente comando per crearne uno:
   ```bash
   pod init
   ```
1. Aggiungi questa riga al tuo `Podfile`:
   ```podfile
   pod 'StripePaymentsUI'
   ```
1. Esegui il seguente comando:
   ```bash
   pod install
   ```
1. Ricordati di utilizzare d’ora in poi il file `.xcworkspace` per aprire il progetto in Xcode, anziché il file `.xcodeproj` file.
1. In futuro, per eseguire l’aggiornamento alla versione più recente dell’SDK, esegui questo comando:
   ```bash
   pod update StripePaymentsUI
   ```

#### Carthage

1. Se non l’hai ancora fatto, installa la versione più recente di [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Aggiungi questa riga al tuo `Cartfile`:
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. Segui le [istruzioni per l’installazione di Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Assicurati di integrare tutti i framework necessari elencati [qui](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking).
1. In futuro, per eseguire l’aggiornamento alla versione più recente del nostro SDK, esegui il seguente comando:
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### Framework manuale

1. Vai alla [pagina delle versioni di GitHub](https://github.com/stripe/stripe-ios/releases/latest) e scarica e decomprimi **Stripe.xcframework.zip**.
1. Trascina **StripePaymentsUI.xcframework** nella sezione **Embedded Binaries** (File binari incorporati) delle impostazioni **General** (Generali) nel tuo progetto Xcode. Assicurati che sia selezionato **Copy items if needed** (Copia elementi se necessario).
1. Ripeti il passaggio 2 per tutti i framework necessari elencati [qui](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking).
1. In futuro, per eseguire l’aggiornamento alla versione più recente del nostro SDK, ripeti i passaggi 1-3.

> Per ulteriori informazioni sulla versione più recente e su quelle precedenti dell’SDK, consulta la pagina [Versioni](https://github.com/stripe/stripe-ios/releases) su GitHub. Per ricevere notifiche quando viene pubblicata una nuova versione, [guarda le versioni](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) del repository.

Configura l’SDK con la tua [chiave pubblicabile](https://dashboard.stripe.com/test/apikeys) di Stripe all’avvio dell’app. In questo modo l’app può inviare le richieste all’API Stripe.

#### Swift

```swift
import UIKitimportStripePaymentsUI

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

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

## Creare un PaymentIntent [Lato server] [Lato client]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) è un oggetto che rappresenta la tua intenzione di riscuotere un pagamento da un cliente e traccia il ciclo di vita del processo di pagamento in ogni sua fase.

### Lato server

Innanzitutto crea un `PaymentIntent` sul tuo server e specifica l’importo da riscuotere e la valuta. Se hai già un’integrazione che utilizza l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), aggiungi `afterpay_clearpay` all’elenco dei [tipi di metodi di pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) per il tuo `PaymentIntent`.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay"
```

### Altre opzioni delle modalità di pagamento

Puoi specificare un parametro `reference` facoltativo nelle [opzioni relative al metodo di pagamento](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) del tuo `PaymentIntent` puoi specificare un parametro di riferimento facoltativo che definisce un identificatore interno dell’ordine per il pagamento. Sebbene questo identificatore non sia solitamente visibile né all’attività né al consumatore, il team di assistenza interno di Afterpay può accedervi in caso di richieste di assistenza manuale. L’identificatore è limitato a 128 caratteri e può contenere solo lettere, cifre, trattini bassi, barre rovesciate e trattini.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \-d "payment_method_options[afterpay_clearpay][reference]"="order_123"
```

### Lato client

Nel PaymentIntent restituito è presente una *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)), che il client può utilizzare per completare la procedura di pagamento in modo sicuro anziché specificare tutto l’oggetto PaymentIntent. Sul lato client, richiedi un PaymentIntent dal tuo server e memorizza la chiave privata client.

#### Swift

```swift
import UIKit
import StripePayments

class CheckoutViewController: UIViewController {
  var paymentIntentClientSecret: String?

  func startCheckout() {
      // Request a PaymentIntent from your server and store its client secret
  }
}
```

## Raccogliere i dati relativi alla modalità di pagamento [Lato client]

Perché il pagamento vada a buon fine, Afterpay ha bisogno che siano presenti i dati di fatturazione. Nella tua app, acquisisci dal cliente i dati di fatturazione necessari:

- Nome e cognome
- Indirizzo email
- Indirizzo di fatturazione completo

Crea un oggetto [STPPaymentMethodParams](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentMethodParams.html) con questi dati.

Inoltre, anche se i dettagli di spedizione non sono obbligatori, possono aiutare a migliorare i tassi di autenticazione. Per raccogliere i dettagli di spedizione, acquisisci dal cliente quanto segue:

- Nome completo
- Indirizzo di spedizione completo

Crea un oggetto [STPPaymentIntentShippingDetailsAddressParams](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentIntentShippingDetailsAddressParams.html) con questi dati.

#### Swift

```swift
// Billing details
let billingDetails = STPPaymentMethodBillingDetails()
billingDetails.name = "Jane Doe"
billingDetails.email = "email@email.com"
let billingAddress = STPPaymentMethodAddress()
billingAddress.line1 = "510 Townsend St."
billingAddress.postalCode = "94102"
billingAddress.country = "US"
billingDetails.address = billingAddress

// Afterpay PaymentMethod params
let afterpayParams = STPPaymentMethodParams(afterpayClearpay: STPPaymentMethodAfterpayClearpayParams(),
                                                                             billingDetails: billingDetails,
                                                                             metadata: nil)

// Shipping details
// Shipping details are optional but recommended to pass in.
let shippingAddress = STPPaymentIntentShippingDetailsAddressParams(line1: "510 Townsend St.")
shippingAddress.country = "US"
shippingAddress.postalCode = "94102"
let shippingDetails = STPPaymentIntentShippingDetailsParams(address: shippingAddress, name: "Jane Doe")
```

## Inviare il pagamento a Stripe [Lato client]

Recupera la chiave privata client dal PaymentIntent che hai creato nel passaggio 2 e chiama il metodo [STPPaymentHandler confirmPayment:](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:). Verrà visualizzata una vista web dove il cliente potrà completare il pagamento e viene quindi chiamato il blocco di completamento con il risultato del pagamento.

#### Swift

```swift
let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)
paymentIntentParams.paymentMethodParams = afterpayParams
// Shipping details are optional but recommended to pass in.
paymentIntentParams.shipping = shippingDetails

STPPaymentHandler.shared().confirmPayment(paymentIntentParams, with: self) { (handlerStatus, paymentIntent, error) in
    switch handlerStatus {
    case .succeeded:
        // Payment succeeded

    case .canceled:
        // Payment was canceled

    case .failed:
        // Payment failed

    @unknown default:
        fatalError()
    }
}
```

## Optional: Aggiungere voci riga al PaymentIntent

Se vuoi, puoi accettare i dati delle voci riga per fornire ulteriori segnali di rischio ad Afterpay. Questa funzione è attualmente in versione beta privata. Contattaci utilizzando il modulo presente su [assistenza Stripe](https://support.stripe.com) se desideri richiedere l’accesso.

## Optional: Separare l'autorizzazione dall'acquisizione

Anziché [separare l’autorizzazione dall’acquisizione per i pagamenti con carta](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md), Afterpay addebita al cliente la prima rata del pagamento al momento dell’autorizzazione. Poi hai fino a 13 giorni dopo l’autorizzazione per acquisire il resto del pagamento. Se non acquisisci il pagamento in questo intervallo di tempo, il cliente riceve un rimborso della prima rata e non gli vengono addebitate altre rate. In questi casi, Stripe annulla anche il PaymentIntent e invia un evento [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Se sai di non poter acquisire il pagamento, ti consigliamo di [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) anziché attendere che trascorrano i 13 giorni. Se annulli in modo proattivo il PaymentIntent, il cliente riceve immediatamente il rimborso della prima rata, evitando confusioni sugli addebiti sul suo estratto conto.

### Indicare a Stripe di eseguire solo l’autorizzazione

Per indicare che vuoi separare l’autorizzazione dall’acquisizione, imposta [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) su `manual` quando crei il PaymentIntent. Il parametro indica a Stripe di limitarsi ad autorizzare l’importo sul conto Afterpay del cliente.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \
  -d "capture_method"="manual" \
  -d "shipping[name]"="Jenny Rosen" \
  -d "shipping[address][line1]"="1234 Main Street" \
  -d "shipping[address][city]"="San Francisco" \
  -d "shipping[address][state]"="CA" \
  -d "shipping[address][country]"="US" \
  -d "shipping[address][postal_code]"=94111
```

In seguito alla concessione dell’autorizzazione, Stripe invia un evento [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Consulta la nostra [Guida agli eventi](https://docs.stripe.com/api/events.md) per saperne di più.

### Acquisire i fondi

Dopo l’avvenuta autorizzazione, lo [stato](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) PaymentIntent diventa `requires_capture`. Per acquisire i fondi autorizzati, effettua una richiesta di [acquisizione](https://docs.stripe.com/api/payment_intents/capture.md) del PaymentIntent. L’importo totale autorizzato viene acquisito per impostazione predefinita. Non puoi acquisire un importo superiore, ma puoi acquisire un importo inferiore.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/capture \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount_to_capture=750
```

### (Facoltativo) Annullare l’autorizzazione

Per annullare un’autorizzazione, puoi [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment).

## Optional: 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 la Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizzato o una soluzione partner per ricevere questi eventi ed eseguire azioni come l’invio della 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 un callback dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione del callback e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente anche di accettare metodi di pagamento diversi in futuro. Ulteriori informazioni sulle [differenze tra tutti i metodi di pagamento supportati](https://stripe.com/payments/payment-methods-guide).

- **Gestisci gli eventi manualmente nella dashboard**

  Utilizza la dashboard per [visualizzare i pagamenti di test nella dashboard](https://dashboard.stripe.com/test/payments), inviare le ricevute tramite email, gestire i bonifici o ritentare i pagamenti non riusciti.

- **Crea un webhook personalizzato**

  [Crea un gestore webhook personalizzato](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) per rilevare gli eventi e creare flussi di pagamento asincroni personalizzati. Esegui il test e il debug in locale dell’integrazione webhook con la CLI di Stripe.

- **Integra un’app preimpostata**

  Gestisci eventi comuni dell’attività, come l’[automazione](https://stripe.partners/?f_category=automation), il [marketing e i saldi](https://stripe.partners/?f_category=marketing-and-sales), integrando una richiesta di registrazione del partner.

## Optional: Testare l'integrazione Afterpay

Testa la tua integrazione Afterpay con le tue chiavi API di test visualizzando la pagina di reindirizzamento. Puoi testare il caso di pagamento riuscito autenticando il pagamento sulla pagina di reindirizzamento. Il PaymentIntent passerà da `requires_action` a `succeeded`.

Per testare il caso in cui l’utente non riesce a effettuare l’autenticazione, usa le tue chiavi API di test e visualizza la pagina di reindirizzamento. In questa pagina, fai clic su **Interrompi pagamento di test**. Il PaymentIntent passerà da `requires_action` a `requires_payment_method`.

Per i PaymentIntent con [acquisizione manuale](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) in modalità di test, il PaymentIntent non acquisito scade automaticamente 10 minuti dopo che viene concessa l’autorizzazione.

## Pagamenti non riusciti

Afterpay decide se accettare o rifiutare una transazione in base a diversi fattori, ad esempio da quanto tempo l’acquirente utilizza Afterpay, l’importo in sospeso che il cliente deve rimborsare o il valore dell’ordine corrente.

Dato che i pagamenti Afterpay hanno un tasso di rifiuto più elevato rispetto a molti metodi di pagamento, dovresti sempre includere opzioni di pagamento aggiuntive nel tuo flusso di pagamento, come ad esempio `card`. In questi casi, il [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) viene scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) diventa automaticamente a `requires_payment_method`.

Per un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) Afterpay con stato `requires_action`, i clienti devono completare il pagamento entro tre ore dal reindirizzamento al sito Afterpay (ciò non riguarda i pagamenti rifiutati). In caso contrario, l’oggetto [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) verrà scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) passerà automaticamente a `requires_payment_method`

In questi casi, invita il cliente a riprovare con una diversa opzione di pagamento presente nel tuo flusso di completamento della transazione.

## Codici di errore

Questi sono i codici di errore più diffusi e le corrispondenti azioni consigliate:

| Codice di errore                         | Azione consigliata                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Un errore generico che indica che Afterpay Checkout non è andato a buon fine. Può trattarsi anche di un pagamento rifiutato che non viene visualizzato come codice di errore pagamento rifiutato.                                                                                                                    |
| `payment_method_provider_decline`        | Afterpay ha rifiutato il pagamento del cliente. Successivamente, il cliente dovrà contattare Afterpay per richiedere ulteriori informazioni.                                                                                                                                                                         |
| `payment_intent_payment_attempt_expired` | Il cliente non ha mai completato il pagamento sulla pagina di completamento della transazione di Afterpay e la sessione di pagamento è scaduta. Tre ore dopo la creazione iniziale del completamento della transazione, Stripe fa scadere automaticamente i PaymentIntents che non vengono autorizzati con successo. |
| `payment_method_not_available`           | Afterpay ha riscontrato un errore relativo al servizio e non è in grado di completare la richiesta. Riprova più tardi.                                                                                                                                                                                               |
| `amount_too_small`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |
| `amount_too_large`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |


# Android

> This is a Android for when payment-ui is mobile and platform is android. View the full page at https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment?payment-ui=mobile&platform=android.

L’accettazione di Afterpay nella tua app consiste nella visualizzazione di una vista web con cui il cliente deve autenticare il proprio pagamento. Il cliente torna quindi alla tua app e tu puoi *verificare* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) immediatamente se il pagamento ha avuto esito positivo o negativo.

> Prima di avviare l’integrazione, assicurati che il tuo account sia idoneo per Afterpay accedendo alle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods).

## Configura 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 per Android di Stripe](https://github.com/stripe/stripe-android) è open source e [completamente documentato](https://stripe.dev/stripe-android/).

Per installare l’SDK, aggiungi `stripe-android` al blocco `dependencies` del tuo file [app/build.gradle](https://developer.android.com/studio/build/dependencies):

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.8.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.8.0")
}
```

> Per ulteriori informazioni sulla versione più recente e su quelle precedenti dell’SDK, consulta la pagina [Releases](https://github.com/stripe/stripe-android/releases) su GitHub. Per ricevere una notifica quando viene pubblicata una nuova versione, [imposta il controllo delle versioni per il repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).

Configura l’SDK con la tua [chiave pubblicabile](https://dashboard.stripe.com/apikeys) di Stripe in modo che possa inviare le richieste all’API Stripe, ad esempio nella sottoclasse `Application`:

#### Kotlin

```kotlin
import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

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

I nostri esempi di codice Stripe utilizzano inoltre [OkHttp](https://github.com/square/okhttp) e [GSON](https://github.com/google/gson) per inviare richieste HTTP a un server.

## Creare un PaymentIntent [Lato server] [Lato client]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) è un oggetto che rappresenta la tua intenzione di riscuotere un pagamento da un cliente e traccia il ciclo di vita del processo di pagamento in ogni sua fase.

### Lato server

Innanzitutto crea un `PaymentIntent` sul tuo server e specifica l’importo da riscuotere e la valuta. Se hai già un’integrazione che utilizza l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), aggiungi `afterpay_clearpay` all’elenco dei [tipi di metodi di pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) per il tuo `PaymentIntent`.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay"
```

### Altre opzioni delle modalità di pagamento

Puoi specificare un parametro `reference` facoltativo nelle [opzioni relative al metodo di pagamento](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) del tuo `PaymentIntent` puoi specificare un parametro di riferimento facoltativo che definisce un identificatore interno dell’ordine per il pagamento. Sebbene questo identificatore non sia solitamente visibile né all’attività né al consumatore, il team di assistenza interno di Afterpay può accedervi in caso di richieste di assistenza manuale. L’identificatore è limitato a 128 caratteri e può contenere solo lettere, cifre, trattini bassi, barre rovesciate e trattini.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \-d "payment_method_options[afterpay_clearpay][reference]"="order_123"
```

### Lato client

Nel PaymentIntent restituito è presente una *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)), che il client può utilizzare per completare la procedura di pagamento in modo sicuro anziché specificare tutto l’oggetto PaymentIntent. Sul lato client, richiedi un PaymentIntent dal tuo server e memorizza la chiave privata client.

#### Kotlin

```kotlin
class AfterpayPaymentActivity: AppCompatActivity() {
    private lateinit var paymentIntentClientSecret: String

    override fun onCreate(savedInstanceState: Bundle?) {
        // ...
        startCheckout()
    }


    private fun startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
    }
}
```

## Raccogliere i dati relativi alla modalità di pagamento [Lato client]

Perché il pagamento vada a buon fine, Afterpay ha bisogno che siano presenti i dati di fatturazione. Nella tua app, acquisisci dal cliente i dati di fatturazione necessari:

- Nome e cognome
- Indirizzo email
- Indirizzo di fatturazione completo

Crea un [PaymentMethodCreateParams](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-payment-method-create-params/index.html) con questi dati.

Inoltre, anche se i dettagli di spedizione non sono obbligatori, possono aiutare a migliorare i tassi di autenticazione. Per raccogliere i dettagli di spedizione, acquisisci dal cliente quanto segue:

- Nome completo
- Indirizzo di spedizione completo

Crea un [ConfirmPaymentIntentParams.Shipping](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-confirm-payment-intent-params/-shipping/index.html) con questi dati.

#### Kotlin

```kotlin
val billingDetails = PaymentMethod.BillingDetails(
  name = "Jenny Rosen",
  email = "jenny@rosen.com",
  address = Address.Builder()
    .setLine1("1234 Market St")
    .setCity("San Francisco")
    .setState("CA")
    .setCountry("US")
    .setPostalCode("94111")
    .build()
)
val paymentMethodCreateParams = PaymentMethodCreateParams.createAfterpayClearpay(billingDetails)

// Shipping details are optional but recommended to pass in.
val shippingDetails = ConfirmPaymentIntentParams.Shipping(
  name = "Jenny Rosen",
  address = Address.Builder()
    .setLine1("1234 Market St")
    .setCity("San Francisco")
    .setState("CA")
    .setCountry("US")
    .setPostalCode("94111")
    .build()
)
```

## Inviare il pagamento a Stripe [Lato client]

Recupera la chiave privata client dal PaymentIntent che hai creato nel passaggio 2 e richiama il metodo di [conferma PaymentLauncher](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690). Verrà visualizzata una schermata web in cui il cliente potrà completare il pagamento sul sito web o sull’app della propria banca. Successivamente, verrà richiamato onActivityResult con il risultato del pagamento.

#### Kotlin

```kotlin

class AfterpayPaymentActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private val paymentLauncher: PaymentLauncher by lazy {
        val paymentConfiguration = PaymentConfiguration.getInstance(applicationContext)
        PaymentLauncher.Companion.create(
            this,
            paymentConfiguration.publishableKey,
            paymentConfiguration.stripeAccountId,
            ::onPaymentResult
        )
    }

    private fun startCheckout() {
        // ...

        // Shipping details are optional but recommended to pass in.
        val confirmParams = ConfirmPaymentIntentParams
            .createWithPaymentMethodCreateParams(
                paymentMethodCreateParams = paymentMethodCreateParams,
                clientSecret = paymentIntentClientSecret,
                shipping = shippingDetails
            )
        paymentLauncher.confirm(confirmParams)
    }

    private fun onPaymentResult(paymentResult: PaymentResult) {
        when (paymentResult) {
            is PaymentResult.Completed -> {
                // show success UI
            }
            is PaymentResult.Canceled -> {
                // handle cancel flow
            }
            is PaymentResult.Failed -> {
                // handle failures
                // (for example, the customer may need to choose a new payment
                // method)
            }
        }
    }
}
```

## Optional: Aggiungere voci riga al PaymentIntent

Se vuoi, puoi accettare i dati delle voci riga per fornire ulteriori segnali di rischio ad Afterpay. Questa funzione è attualmente in versione beta privata. Contattaci utilizzando il modulo presente su [assistenza Stripe](https://support.stripe.com) se desideri richiedere l’accesso.

## Optional: Separare l'autorizzazione dall'acquisizione

Anziché [separare l’autorizzazione dall’acquisizione per i pagamenti con carta](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md), Afterpay addebita al cliente la prima rata del pagamento al momento dell’autorizzazione. Poi hai fino a 13 giorni dopo l’autorizzazione per acquisire il resto del pagamento. Se non acquisisci il pagamento in questo intervallo di tempo, il cliente riceve un rimborso della prima rata e non gli vengono addebitate altre rate. In questi casi, Stripe annulla anche il PaymentIntent e invia un evento [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Se sai di non poter acquisire il pagamento, ti consigliamo di [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) anziché attendere che trascorrano i 13 giorni. Se annulli in modo proattivo il PaymentIntent, il cliente riceve immediatamente il rimborso della prima rata, evitando confusioni sugli addebiti sul suo estratto conto.

### Indicare a Stripe di eseguire solo l’autorizzazione

Per indicare che vuoi separare l’autorizzazione dall’acquisizione, imposta [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) su `manual` quando crei il PaymentIntent. Il parametro indica a Stripe di limitarsi ad autorizzare l’importo sul conto Afterpay del cliente.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \
  -d "capture_method"="manual" \
  -d "shipping[name]"="Jenny Rosen" \
  -d "shipping[address][line1]"="1234 Main Street" \
  -d "shipping[address][city]"="San Francisco" \
  -d "shipping[address][state]"="CA" \
  -d "shipping[address][country]"="US" \
  -d "shipping[address][postal_code]"=94111
```

In seguito alla concessione dell’autorizzazione, Stripe invia un evento [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Consulta la nostra [Guida agli eventi](https://docs.stripe.com/api/events.md) per saperne di più.

### Acquisire i fondi

Dopo l’avvenuta autorizzazione, lo [stato](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) PaymentIntent diventa `requires_capture`. Per acquisire i fondi autorizzati, effettua una richiesta di [acquisizione](https://docs.stripe.com/api/payment_intents/capture.md) del PaymentIntent. L’importo totale autorizzato viene acquisito per impostazione predefinita. Non puoi acquisire un importo superiore, ma puoi acquisire un importo inferiore.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/capture \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount_to_capture=750
```

### (Facoltativo) Annullare l’autorizzazione

Per annullare un’autorizzazione, puoi [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment).

## Optional: 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 la Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizzato o una soluzione partner per ricevere questi eventi ed eseguire azioni come l’invio della 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 un callback dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione del callback e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente anche di accettare metodi di pagamento diversi in futuro. Ulteriori informazioni sulle [differenze tra tutti i metodi di pagamento supportati](https://stripe.com/payments/payment-methods-guide).

- **Gestisci gli eventi manualmente nella dashboard**

  Utilizza la dashboard per [visualizzare i pagamenti di test nella dashboard](https://dashboard.stripe.com/test/payments), inviare le ricevute tramite email, gestire i bonifici o ritentare i pagamenti non riusciti.

- **Crea un webhook personalizzato**

  [Crea un gestore webhook personalizzato](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) per rilevare gli eventi e creare flussi di pagamento asincroni personalizzati. Esegui il test e il debug in locale dell’integrazione webhook con la CLI di Stripe.

- **Integra un’app preimpostata**

  Gestisci eventi comuni dell’attività, come l’[automazione](https://stripe.partners/?f_category=automation), il [marketing e i saldi](https://stripe.partners/?f_category=marketing-and-sales), integrando una richiesta di registrazione del partner.

## Optional: Testare l'integrazione Afterpay

Testa la tua integrazione Afterpay con le tue chiavi API di test visualizzando la pagina di reindirizzamento. Puoi testare il caso di pagamento riuscito autenticando il pagamento sulla pagina di reindirizzamento. Il PaymentIntent passerà da `requires_action` a `succeeded`.

Per testare il caso in cui l’utente non riesce a effettuare l’autenticazione, usa le tue chiavi API di test e visualizza la pagina di reindirizzamento. In questa pagina, fai clic su **Interrompi pagamento di test**. Il PaymentIntent passerà da `requires_action` a `requires_payment_method`.

Per i PaymentIntent con [acquisizione manuale](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) in modalità di test, il PaymentIntent non acquisito scade automaticamente 10 minuti dopo che viene concessa l’autorizzazione.

## Pagamenti non riusciti

Afterpay decide se accettare o rifiutare una transazione in base a diversi fattori, ad esempio da quanto tempo l’acquirente utilizza Afterpay, l’importo in sospeso che il cliente deve rimborsare o il valore dell’ordine corrente.

Dato che i pagamenti Afterpay hanno un tasso di rifiuto più elevato rispetto a molti metodi di pagamento, dovresti sempre includere opzioni di pagamento aggiuntive nel tuo flusso di pagamento, come ad esempio `card`. In questi casi, il [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) viene scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) diventa automaticamente a `requires_payment_method`.

Per un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) Afterpay con stato `requires_action`, i clienti devono completare il pagamento entro tre ore dal reindirizzamento al sito Afterpay (ciò non riguarda i pagamenti rifiutati). In caso contrario, l’oggetto [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) verrà scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) passerà automaticamente a `requires_payment_method`

In questi casi, invita il cliente a riprovare con una diversa opzione di pagamento presente nel tuo flusso di completamento della transazione.

## Codici di errore

Questi sono i codici di errore più diffusi e le corrispondenti azioni consigliate:

| Codice di errore                         | Azione consigliata                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Un errore generico che indica che Afterpay Checkout non è andato a buon fine. Può trattarsi anche di un pagamento rifiutato che non viene visualizzato come codice di errore pagamento rifiutato.                                                                                                                    |
| `payment_method_provider_decline`        | Afterpay ha rifiutato il pagamento del cliente. Successivamente, il cliente dovrà contattare Afterpay per richiedere ulteriori informazioni.                                                                                                                                                                         |
| `payment_intent_payment_attempt_expired` | Il cliente non ha mai completato il pagamento sulla pagina di completamento della transazione di Afterpay e la sessione di pagamento è scaduta. Tre ore dopo la creazione iniziale del completamento della transazione, Stripe fa scadere automaticamente i PaymentIntents che non vengono autorizzati con successo. |
| `payment_method_not_available`           | Afterpay ha riscontrato un errore relativo al servizio e non è in grado di completare la richiesta. Riprova più tardi.                                                                                                                                                                                               |
| `amount_too_small`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |
| `amount_too_large`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |


# React Native

> This is a React Native for when payment-ui is mobile and platform is react-native. View the full page at https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment?payment-ui=mobile&platform=react-native.

> Il contenuto di questa sezione fa riferimento a un prodotto *precedente* (Technology that's no longer recommended). Per conoscere il percorso di integrazione più recente, consulta la guida [Accettare un pagamento](https://docs.stripe.com/payments/accept-a-payment.md). Sebbene Stripe supporti ancora questo prodotto, qualora il prodotto dovesse diventare obsoleto questo tipo di assistenza potrebbe terminare.

Gli utenti Stripe possono usare l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md) con un percorso di integrazione unico per creare pagamenti utilizzando qualsiasi modalità supportata per accettare pagamenti [Afterpay](https://www.afterpay.com/) da clienti nei seguenti Paesi:

- Australia
- Canada
- Nuova Zelanda
- Regno Unito
- Stati Uniti

Afterpay è un metodo di pagamento [monouso](https://docs.stripe.com/payments/payment-methods.md#usage) con [notifica immediata](https://docs.stripe.com/payments/payment-methods.md#payment-notification) che richiede ai clienti di [autenticare](https://docs.stripe.com/payments/payment-methods.md#customer-actions) il pagamento. I clienti vengono reindirizzati al sito Afterpay dove possono accettare i termini di un piano di rateizzazione. Quando il cliente accetta i termini, i fondi vengono garantiti e trasferiti sul tuo account Stripe. Il cliente ripaga direttamente Afterpay nel tempo.

> Prima di avviare l’integrazione, assicurati che il tuo account sia idoneo per Afterpay accedendo alle [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods).

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

### Lato server

Per questa integrazione sono necessari endpoint sul server che parlano 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.

## Creare un PaymentIntent [Lato server] [Lato client]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) è un oggetto che rappresenta la tua intenzione di riscuotere un pagamento da un cliente e traccia il ciclo di vita del processo di pagamento in ogni sua fase.

### Lato server

Innanzitutto crea un `PaymentIntent` sul tuo server e specifica l’importo da riscuotere e la valuta. Se hai già un’integrazione che utilizza l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), aggiungi `afterpay_clearpay` all’elenco dei [tipi di metodi di pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) per il tuo `PaymentIntent`.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay"
```

### Lato client

Nel PaymentIntent restituito è presente una *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)), che il client può utilizzare per completare la procedura di pagamento in modo sicuro anziché specificare tutto l’oggetto PaymentIntent. Sul lato client, richiedi un PaymentIntent dal tuo server e memorizza la chiave privata client.

```javascript
const fetchPaymentIntentClientSecret = async () => {
  const response = await fetch(`${API_URL}/create-payment-intent`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      currency: 'usd',
      payment_method_types: ['afterpay_clearpay'],
    }),
  });
  const {clientSecret, error} = await response.json();

  return {clientSecret, error};
};
```

## Raccogliere i dati relativi alla modalità di pagamento [Lato client]

Perché il pagamento vada a buon fine, Afterpay ha bisogno che siano presenti i dati di fatturazione. Nella tua app, acquisisci dal cliente i dati di fatturazione necessari:

- Nome e cognome
- Indirizzo email
- Indirizzo di fatturazione completo

Inoltre, anche se i dettagli di spedizione non sono obbligatori, possono aiutare a migliorare i tassi di autenticazione. Per raccogliere i dettagli di spedizione, acquisisci dal cliente quanto segue:

- Nome completo
- Indirizzo di spedizione completo

```javascript
export default function AfterpayClearpayPaymentScreen() {
  const [email, setEmail] = useState('');

  const handlePayPress = async () => {
    const billingDetails: PaymentMethodCreateParams.BillingDetails = {
      email,
      phone: '+48888000888',
      addressCity: 'Houston',
      addressCountry: 'US',
      addressLine1: '1459  Circle Drive',
      addressLine2: 'Texas',
      addressPostalCode: '77063',
      name: 'Jenny Rosen',
    };

    // Shipping details are optional but recommended to pass in.
    const shippingDetails: PaymentMethodCreateParams.ShippingDetails = {
      addressLine1: '1459  Circle Drive',
      addressCountry: 'US',
      addressPostalCode: '77063',
      name: 'Jenny Rosen',
    };

    // ...
  };

  return (
    <Screen>
      <TextInput
        placeholder="E-mail"
        onChange={(value) => setEmail(value.nativeEvent.text)}
      />
    </Screen>
  );
}
```

## Inviare il pagamento a Stripe [Lato client]

Recupera la chiave privata client dal PaymentIntent che hai creato e chiama `confirmPayment`. La chiave privata client deve essere gestita con cura in quanto può effettuare l’addebito. Non registrarla, non inserirla negli URL e mostrala solo al cliente.

```javascript
export default function AfterpayClearpayPaymentScreen() {
  const [email, setEmail] = useState('');

  const handlePayPress = async () => {
    // ...

    const {error, paymentIntent} = await confirmPayment(clientSecret, {
      paymentMethodType: 'AfterpayClearpay',
      paymentMethodData: {
        billingDetails,
        // Shipping details are optional but recommended to pass in.
        shippingDetails,
      },
    });

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else if (paymentIntent) {
      Alert.alert(
        'Success',
        `The payment was confirmed successfully! currency: ${paymentIntent.currency}`,
      );
    }
  };

  return <Screen>{/* ... */}</Screen>;
}
```

## Optional: Gestire il deep linking

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.
1. [Configura](https://reactnative.dev/docs/linking) il tuo URL personalizzato.
1. 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 } 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>
  );
}
```

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).

## Optional: Aggiungere voci riga al PaymentIntent

Se vuoi, puoi accettare i dati delle voci riga per fornire ulteriori segnali di rischio ad Afterpay. Questa funzione è attualmente in versione beta privata. Contattaci utilizzando il modulo presente su [assistenza Stripe](https://support.stripe.com) se desideri richiedere l’accesso.

## Optional: Separare l'autorizzazione dall'acquisizione

Anziché [separare l’autorizzazione dall’acquisizione per i pagamenti con carta](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md), Afterpay addebita al cliente la prima rata del pagamento al momento dell’autorizzazione. Poi hai fino a 13 giorni dopo l’autorizzazione per acquisire il resto del pagamento. Se non acquisisci il pagamento in questo intervallo di tempo, il cliente riceve un rimborso della prima rata e non gli vengono addebitate altre rate. In questi casi, Stripe annulla anche il PaymentIntent e invia un evento [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Se sai di non poter acquisire il pagamento, ti consigliamo di [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) anziché attendere che trascorrano i 13 giorni. Se annulli in modo proattivo il PaymentIntent, il cliente riceve immediatamente il rimborso della prima rata, evitando confusioni sugli addebiti sul suo estratto conto.

### Indicare a Stripe di eseguire solo l’autorizzazione

Per indicare che vuoi separare l’autorizzazione dall’acquisizione, imposta [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) su `manual` quando crei il PaymentIntent. Il parametro indica a Stripe di limitarsi ad autorizzare l’importo sul conto Afterpay del cliente.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="afterpay_clearpay" \
  -d "capture_method"="manual" \
  -d "shipping[name]"="Jenny Rosen" \
  -d "shipping[address][line1]"="1234 Main Street" \
  -d "shipping[address][city]"="San Francisco" \
  -d "shipping[address][state]"="CA" \
  -d "shipping[address][country]"="US" \
  -d "shipping[address][postal_code]"=94111
```

In seguito alla concessione dell’autorizzazione, Stripe invia un evento [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Consulta la nostra [Guida agli eventi](https://docs.stripe.com/api/events.md) per saperne di più.

### Acquisire i fondi

Dopo l’avvenuta autorizzazione, lo [stato](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) PaymentIntent diventa `requires_capture`. Per acquisire i fondi autorizzati, effettua una richiesta di [acquisizione](https://docs.stripe.com/api/payment_intents/capture.md) del PaymentIntent. L’importo totale autorizzato viene acquisito per impostazione predefinita. Non puoi acquisire un importo superiore, ma puoi acquisire un importo inferiore.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/capture \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount_to_capture=750
```

### (Facoltativo) Annullare l’autorizzazione

Per annullare un’autorizzazione, puoi [annullare il PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment).

## Optional: 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 la Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizzato o una soluzione partner per ricevere questi eventi ed eseguire azioni come l’invio della 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 un callback dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione del callback e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente anche di accettare metodi di pagamento diversi in futuro. Ulteriori informazioni sulle [differenze tra tutti i metodi di pagamento supportati](https://stripe.com/payments/payment-methods-guide).

- **Gestisci gli eventi manualmente nella dashboard**

  Utilizza la dashboard per [visualizzare i pagamenti di test nella dashboard](https://dashboard.stripe.com/test/payments), inviare le ricevute tramite email, gestire i bonifici o ritentare i pagamenti non riusciti.

- **Crea un webhook personalizzato**

  [Crea un gestore webhook personalizzato](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) per rilevare gli eventi e creare flussi di pagamento asincroni personalizzati. Esegui il test e il debug in locale dell’integrazione webhook con la CLI di Stripe.

- **Integra un’app preimpostata**

  Gestisci eventi comuni dell’attività, come l’[automazione](https://stripe.partners/?f_category=automation), il [marketing e i saldi](https://stripe.partners/?f_category=marketing-and-sales), integrando una richiesta di registrazione del partner.

## Optional: Testare l'integrazione Afterpay

Testa la tua integrazione Afterpay con le tue chiavi API di test visualizzando la pagina di reindirizzamento. Puoi testare il caso di pagamento riuscito autenticando il pagamento sulla pagina di reindirizzamento. Il PaymentIntent passerà da `requires_action` a `succeeded`.

Per testare il caso in cui l’utente non riesce a effettuare l’autenticazione, usa le tue chiavi API di test e visualizza la pagina di reindirizzamento. In questa pagina, fai clic su **Interrompi pagamento di test**. Il PaymentIntent passerà da `requires_action` a `requires_payment_method`.

Per i PaymentIntent con [acquisizione manuale](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) in modalità di test, il PaymentIntent non acquisito scade automaticamente 10 minuti dopo che viene concessa l’autorizzazione.

## Pagamenti non riusciti

Afterpay decide se accettare o rifiutare una transazione in base a diversi fattori, ad esempio da quanto tempo l’acquirente utilizza Afterpay, l’importo in sospeso che il cliente deve rimborsare o il valore dell’ordine corrente.

Dato che i pagamenti Afterpay hanno un tasso di rifiuto più elevato rispetto a molti metodi di pagamento, dovresti sempre includere opzioni di pagamento aggiuntive nel tuo flusso di pagamento, come ad esempio `card`. In questi casi, il [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) viene scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) diventa automaticamente a `requires_payment_method`.

Per un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) Afterpay con stato `requires_action`, i clienti devono completare il pagamento entro tre ore dal reindirizzamento al sito Afterpay (ciò non riguarda i pagamenti rifiutati). In caso contrario, l’oggetto [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) verrà scollegato e lo stato dell’oggetto [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) passerà automaticamente a `requires_payment_method`

In questi casi, invita il cliente a riprovare con una diversa opzione di pagamento presente nel tuo flusso di completamento della transazione.

## Codici di errore

Questi sono i codici di errore più diffusi e le corrispondenti azioni consigliate:

| Codice di errore                         | Azione consigliata                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Un errore generico che indica che Afterpay Checkout non è andato a buon fine. Può trattarsi anche di un pagamento rifiutato che non viene visualizzato come codice di errore pagamento rifiutato.                                                                                                                    |
| `payment_method_provider_decline`        | Afterpay ha rifiutato il pagamento del cliente. Successivamente, il cliente dovrà contattare Afterpay per richiedere ulteriori informazioni.                                                                                                                                                                         |
| `payment_intent_payment_attempt_expired` | Il cliente non ha mai completato il pagamento sulla pagina di completamento della transazione di Afterpay e la sessione di pagamento è scaduta. Tre ore dopo la creazione iniziale del completamento della transazione, Stripe fa scadere automaticamente i PaymentIntents che non vengono autorizzati con successo. |
| `payment_method_not_available`           | Afterpay ha riscontrato un errore relativo al servizio e non è in grado di completare la richiesta. Riprova più tardi.                                                                                                                                                                                               |
| `amount_too_small`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |
| `amount_too_large`                       | Inserisci un importo compreso nei [limiti di transazione predefiniti](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) di Afterpay per il Paese.                                                                                                                                           |