# Zahlungen per Afterpay oder Clearpay annehmen

Erfahren Sie, wie Sie Zahlungen mit Afterpay annehmen (im Vereinigten Königreich auch unter dem Namen Clearpay bekannt), einer Zahlungsmethode in den USA, CA, UK, AU und NZ.

> Stripe kann Ihren Kundinnen und Kunden automatisch die relevanten Zahlungsmethoden anzeigen, indem Währungen, Einschränkungen der Zahlungsmethode und andere Parameter ausgewertet werden.
> 
> - Befolgen Sie den Leitfaden [Eine Zahlung akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted), um eine Checkout-Integration zu erstellen, die [dynamische Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) verwendet.
- Wenn Sie keine dynamischen Zahlungsmethoden verwenden möchten, befolgen Sie die folgenden Schritte, um die Zahlungsmethoden in Ihrer Checkout-Integration manuell zu konfigurieren.

Afterpay ist eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage) mit [sofortiger Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification), bei der Kundinnen/Kunden ihre Zahlung [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Kundinnen/Kunden werden auf die Afterpay-Website weitergeleitet, wo sie den Bedingungen eines Ratenzahlungsvertrags zustimmen. Wenn die Kundinnen/Kundinnen die Bedingungen akzeptieren, garantiert Afterpay, dass die Gelder für den Kunden/die Kundin verfügbar sind und überweist sie auf Ihr Stripe-Konto. Die Kundinnen/Kunden zahlen die Zahlung über eine gewissen Zeitraum direkt an Afterpay zurück.

> Bevor Sie mit der Integration beginnen, vergewissern Sie sich, dass Ihr Konto für Afterpay geeignet ist. Dies können Sie in Ihren [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) prüfen.

## Kompatibilität bestimmen

**Kundenregion**: Australia, Canada, New Zealand, UK, US

**Unterstützte Währungen**: `aud, cad, nzd, gbp, usd`

**Transaktionswährungen**: `aud, cad, nzd, gbp, usd`

**Zahlungsmodus**: Yes

**Einrichtungsmodus**: No

**Abonnementmodus**: No

Für die Unterstützung von Zahlungen per Afterpay muss eine Checkout-Sitzung alle folgenden Bedingungen erfüllen:

- Sie können nur einmalige Posten verwenden (wiederkehrende *Abonnement* (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)pläne werden nicht unterstützt).
- Sie müssen die *Preise* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) in Ihrer Landeswährung angeben.

## Zahlung annehmen

> Dieser Leitfaden beruht auf der grundlegenden Checkout-Integration für die [Annahme einer Zahlung](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted).

Diese Anleitung führt Sie durch die Aktivierung von Afterpay und zeigt Ihnen die Unterschiede zwischen der Annahme von Zahlungen mit dynamischen Zahlungsmethoden und der manuellen Konfiguration von Zahlungsmethoden.

### Afterpay als Zahlungsmethode aktivieren

Führen Sie bei der Erstellung einer neuen [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) folgende Schritte aus:

1. Fügen Sie `afterpay_clearpay` der Liste der `payment_method_types` hinzu.
1. Stellen Sie sicher, dass alle `line_items` Ihre Landeswährung verwenden und der Gesamtbetrag die [Limits für Transaktionsbeträge](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay nicht übersteigt.
1. Optional können Sie über `shipping_address_collection[allowed_countries]` angeben, welche Länder Checkout als Versandorte zulässt.

#### Von Stripe gehostete Seite

```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"
```

#### Vollständig eingebettete Seite

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

Wenn Sie Versandadressen nicht über Checkout erfassen möchten, können Sie die Versandadresse auch über `payment_intent_data[shipping]` angeben. Dies trägt zur Verbesserung der Kreditbewilligungsquoten bei.

#### Von Stripe gehostete Seite

```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"
```

#### Vollständig eingebettete Seite

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

### Abwicklung Ihrer Bestellungen

[Verwenden Sie eine Methode wie Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um die *Ausführung* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) von Bestellungen zu tätigen. Verlassen Sie sich nicht darauf, dass Ihre Kundinnen/Kunden zur Zahlungsstatusseite zurückkehren.

Die folgenden Ereignisse werden übermittelt, wenn sich der Zahlungsstatus ändert:

| Ereignisname                                                                                                           | Beschreibung                                                                                                                                                                 | Nächste Schritte                                                             |
| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed)       | Die Kundin/der Kunde hat die Zahlung nach der Übermittlung des Checkout-Formulars erfolgreich autorisiert.                                                                   | Warten Sie, bis die Zahlung erfolgt oder fehlschlägt.                        |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)           | Die Zahlung der Kundin/des Kunden war erfolgreich. Der `PaymentIntent` wechselt zu `succeeded`.                                                                              | Wickeln Sie die Bestellung der Kundin/des Kunden ab.                         |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed) | Die Zahlung der Kundin/des Kunden wurde abgelehnt oder ist aus einem anderen Grund fehlgeschlagen. Die `PaymentIntent` wechselt wieder zum Status `requires_payment_method`. | Senden Sie dem/der Kund/in eine E-Mail, um eine neue Bestellung anzufordern. |

Weitere Informationen zur [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md).

## Integration testen

Wählen Sie beim Testen Ihrer Checkout-Integration Afterpay als Zahlungsmethode aus und klicken Sie auf die Schaltfläche **Bezahlen**.

Testen Sie Ihre Afterpay-Integration mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`.

Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`.

Für die [manuelle Erfassung](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) von PaymentIntents im Testmodus läuft der nicht erfasste PaymentIntent 10 Minuten nach erfolgreicher Autorisierung automatisch ab.

## Fehlgeschlagene Zahlungen

Afterpay berücksichtigt mehrere Faktoren bei der Entscheidung, ob eine Transaktion akzeptiert oder abgelehnt wird (zum Beispiel die Dauer der Nutzung von Afterpay durch den/die Käufer/in, den ausstehenden Betrag, den der/die Kund/in zurückzahlen muss, oder den Wert der aktuellen Bestellung).

Sie sollten in Ihrem Bezahlvorgang immer weitere Zahlungsoptionen wie `card` anbieten, da Afterpay-Zahlungen eine höhere Ablehnungsrate haben als viele andere Zahlungsmethoden. In diesen Fällen wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Bei einem Afterpay-[PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) mit dem Status `requires_action` müssen Kundinnen/Kunden die Zahlung innerhalb von 3&nbsp;Stunden nach Weiterleitung zur Afterpay-Website abschließen. Wenn nach 3&nbsp;Stunden keine Aktion erfolgt ist, wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt, und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Teilen Sie Ihren Kund/innen in diesen Fällen mit, dass sie es mit einer anderen Zahlungsoption versuchen sollten, die in Ihrem Bezahlvorgang zur Verfügung gestellt wird.

## Fehlercodes

Im Folgenden finden Sie die häufigsten Fehlercodes und die entsprechenden empfohlenen Maßnahmen:

| Fehlercode                               | Empfohlene Maßnahme                                                                                                                                                                                                                                                                          |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Ein allgemeiner Fehler, der darauf hinweist, dass der Afterpay-Bezahlvorgang fehlgeschlagen ist. Es kann sich auch um eine abgelehnte Zahlung handeln, die nicht als Fehlercode für abgelehnte Zahlungen angezeigt wird.                                                                     |
| `payment_method_provider_decline`        | Afterpay hat die Kundenzahlung abgelehnt. Als nächsten Schritt muss sich der Kunde/die Kundin an Afterpay wenden, um weitere Informationen einzuholen.                                                                                                                                       |
| `payment_intent_payment_attempt_expired` | Die Kundin/der Kunde hat die Zahlung auf der Afterpay-Checkout-Seite nicht abgeschlossen und die Payment-Sitzung ist abgelaufen. Stripe setzt PaymentIntents, die nicht erfolgreich autorisiert wurden, automatisch 3&nbsp;Stunden nach Erstellung des ursprünglichen Checkouts außer Kraft. |
| `payment_method_not_available`           | Bei Afterpay ist ein Servicefehler aufgetreten und die Anfrage kann nicht abgeschlossen werden. Versuchen Sie es zu einem späteren Zeitpunkt erneut.                                                                                                                                         |
| `amount_too_small`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |
| `amount_too_large`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |

## See also

- [Mehr über Afterpay](https://docs.stripe.com/payments/afterpay-clearpay.md)
- [Checkout-Ausführung](https://docs.stripe.com/checkout/fulfillment.md)
- [Checkout anpassen](https://docs.stripe.com/payments/checkout/customization.md)

# Checkout Sessions API

> This is a Checkout Sessions API 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.

Informationen dazu, welche API den Anforderungen Ihres Unternehmens entspricht, finden Sie im [Vergleichsleitfaden](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md), um ein nutzerdefiniertes Stripe-Zahlungsformular in Ihre Website oder Anwendung einzubetten und Kundinnen und Kunden Zahlungsmethoden anzubieten. Erweiterte Konfigurationen und Anpassungen finden Sie im Integrationsleitfaden für die [Zahlungsannahme](https://docs.stripe.com/payments/accept-a-payment.md)

## Kompatibilität bestimmen

**Kundenregion**: Australia, Canada, New Zealand, UK, US

**Unterstützte Währungen**: `aud, cad, nzd, gbp, usd`

**Transaktionswährungen**: `aud, cad, nzd, gbp, usd`

**Zahlungsmodus**: Yes

**Einrichtungsmodus**: No

**Abonnementmodus**: No

Für die Unterstützung von Zahlungen per Afterpay muss eine Checkout-Sitzung alle folgenden Bedingungen erfüllen:

- Sie können nur einmalige Posten verwenden (wiederkehrende *Abonnement* (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)pläne werden nicht unterstützt).
- Sie müssen die *Preise* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) in Ihrer Landeswährung angeben.

## Server einrichten [Serverseitig]

Verwenden Sie die offiziellen Bibliotheken von Stripe für den Zugriff auf die Stripe-API über Ihre Anwendung.

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

## Checkout-Sitzung erstellen [Serverseitig]

Fügen Sie auf Ihrem Server einen Endpoint hinzu, der eine [Checkout-Session](https://docs.stripe.com/api/checkout/sessions/create.md) erstellt und sein [Client-Geheimnis](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret) an Ihr Frontend zurückgibt. Eine Checkout-Sitzung stellt die Sitzung Ihrer Kundin/Ihres Kunden dar, während sie/er für einmalige Käufe oder Abos bezahlt. Checkout-Sitzungen laufen 24&nbsp;Stunden nach Erstellung ab.

Wir empfehlen die Verwendung [dynamischer Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md), um allen Kundinnen und Kunden dynamisch die relevantesten infrage kommenden Zahlungsmethoden anzuzeigen und die Konversionsrate zu maximieren. Sie können [Zahlungsmethoden auch manuell auflisten](https://docs.stripe.com/payments/payment-methods/integration-options.md#listing-payment-methods-manually), wodurch dynamische Zahlungsmethoden deaktiviert werden.

#### Zahlungsmethoden über das Dashboard verwalten

#### 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');
});
```

#### Zahlungsmethoden manuell auflisten

#### 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');
});
```

## Frontend einrichten [Clientseitig]

#### HTML + JS

Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es zum `head` Ihrer HTML-Datei hinzufügen. Laden Sie Stripe.js immer direkt von js.stripe.com, um die PCI-Konformität zu gewährleisten. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie es nicht selbst.

Stellen Sie sicher, dass Sie die neueste Stripe.js-Version verwenden, indem Sie das Script-Tag `einfügen.<script src=“https://js.stripe.com/dahlia/stripe.js”></script>`. Erfahren Sie mehr über die [Versionierung von 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 stellt ein npm-Paket zur Verfügung, mit dem Sie Stripe.js als Modul laden können. Siehe das [Projekt auf GitHub](https://github.com/stripe/stripe-js). Version [7.0.0](https://www.npmjs.com/package/%40stripe/stripe-js/v/7.0.0) oder höher ist erforderlich.

Stripe.js initialisieren

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

Installieren Sie [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) und den [Stripe.js Loader](https://www.npmjs.com/package/@stripe/stripe-js) aus der öffentlichen npm-Registry. Sie benötigen mindestens Version 5.0.0 für React Stripe.js und Version 8.0.0 für den Stripe.js-Loader.

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

Initialisieren Sie eine `stripe`-Instanz auf Ihrem Frontend mit Ihrem veröffentlichbaren Schlüssel.

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

## Bezahlvorgang initialisieren [Clientseitig]

#### HTML + JS

Rufen Sie [initCheckoutElementsSdk](https://docs.stripe.com/js/custom_checkout/init) auf und übergeben Sie `clientSecret`.

`initCheckoutElementsSdk` gibt ein [Checkout](https://docs.stripe.com/js/custom_checkout)-Objekt zurück, das Daten aus der Checkout-Session und Methoden zur Aktualisierung enthält.

Lesen Sie `total` und `lineItems` aus [actions.getSession()](https://docs.stripe.com/js/custom_checkout/session) und zeigen Sie sie in Ihrer Benutzeroberfläche an. So können Sie neue Funktionen mit minimalen Codeänderungen aktivieren. Zum Beispiel erfordert das Hinzufügen [manueller Währungspreise](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) keine UI-Änderungen, wenn `total` angezeigt wird.

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

Umhüllen Sie Ihre Anwendung mit der Komponente [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider) und übergeben Sie dabei `clientSecret` und die `Stripe`-Instanz.

```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;
```

Greifen Sie auf das [Checkout](https://docs.stripe.com/js/custom_checkout)-Objekt in Ihrer Checkout-Formularkomponente, indem Sie den `useCheckoutElements()`-Hook verwenden. Das `Checkout`-Objekt enthält Daten aus der Checkout-Sitzung und Methoden zu ihrer Aktualisierung.

Lesen Sie `total` und `lineItems` aus dem `Checkout`-Objekt und zeigen Sie sie in Ihrer Benutzeroberfläche an. So können Sie Funktionen mit minimalen Codeänderungen aktivieren. Zum Beispiel erfordert das Hinzufügen [manueller Währungspreise](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) keine UI-Änderungen, wenn `total` angezeigt wird.

```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>
  );
};
```

## Kunden-E-Mail-Adresse erfassen [Clientseitig]

#### HTML + JS

Bitte geben Sie beim Abschluss einer Checkout-Sitzung eine gültige E-Mail-Adresse an.

Diese Anweisungen erstellen eine E-Mail-Eingabe und verwenden [updateEmail](https://docs.stripe.com/js/custom_checkout/update_email) aus dem Objekt `Checkout`.

Alternativ können Sie:

- Übergeben Sie die Werte [Kunde_E-Mail](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [Kunden_Konto](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (für Kundinnen und Kunden, die als kundenkonfigurierte `Account`-Objekte dargestellt werden), oder [Kundin/Kunde](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (für Kundinnen und Kunden, die `Customer`-Objekte dargestellt werden), wenn Sie die Checkout-Session erstellen. Stripe validiert E-Mail-Adressen, die in dieser Weise bereitgestellt werden.
- Geben Sie eine E-Mail-Adresse ein, die Sie bereits bei [checkout.confirm](https://docs.stripe.com/js/custom_checkout/confirm) validiert haben.

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

Bitte geben Sie beim Abschluss einer Checkout-Sitzung eine gültige E-Mail-Adresse an.

Diese Anweisungen erstellen eine E-Mail-Eingabe und verwenden [updateEmail](https://docs.stripe.com/js/react_stripe_js/checkout/update_email) aus dem Objekt `Checkout`.

Alternativ können Sie:

- Übergeben Sie die Werte [Kunde_E-Mail](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [Kunden_Konto](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (für Kundinnen und Kunden, die als kundenkonfigurierte `Account`-Objekte dargestellt werden), oder [Kundin/Kunde](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (für Kundinnen und Kunden, die `Customer`-Objekte dargestellt werden), wenn Sie die Checkout-Session erstellen. Stripe validiert E-Mail-Adressen, die in dieser Weise bereitgestellt werden.
- Geben Sie eine E-Mail-Adresse ein, die Sie bereits auf [confirm](https://docs.stripe.com/js/react_stripe_js/checkout/confirm) validiert haben.

```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;
```

## Zahlungsdaten erfassen [Clientseitig]

Erfassen Sie Zahlungsdetails auf dem Client mit dem [Payment Element](https://docs.stripe.com/payments/payment-element.md). Das Payment Element ist eine vorgefertigte Komponente der Nutzeroberfläche, das die Erfassung von Zahlungsdaten für verschiedene Zahlungsmethoden vereinfacht.

Das Payment Element enthält einen iFrame, der Zahlungsinformationen über eine sichere HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da einige Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung voraussetzen.

Wenn Sie sich für die Verwendung eines Iframes entscheiden und Apple Pay oder Google Pay akzeptieren möchten, muss das Attribut [Zulassen](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) des Iframes auf `"payment*"` gesetzt sein.

Die Adresse der Bezahlseite muss mit `https://` beginnen, nicht mit `http://`, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, dieses zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren.

#### HTML + JS

Erstellen Sie zunächst ein Container-DOM-Element, um das [Payment Element](https://docs.stripe.com/payments/payment-element.md) zu verbinden. Erstellen Sie dann eine Instanz des `Payment Element` mit [checkout.createPaymentElement](https://docs.stripe.com/js/custom_checkout/create_payment_element) und verbinden Sie es durch Aufrufen von [element.mount](https://docs.stripe.com/js/element/mount), wobei Sie entweder einen CSS-Selektor oder das Container-DOM-Element angeben.

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

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

Die unterstützten Optionen finden Sie in der [Stripe.js-Dokumentation](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options).

Sie können das [Erscheinungsbild](https://docs.stripe.com/payments/checkout/customization/appearance.md) aller Elements anpassen, indem Sie [elementsOptions.appearance](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions-appearance) übergeben, wenn Sie Checkout im Frontend initialisieren.

#### React

Integrieren Sie die Komponente [Payment Element](https://docs.stripe.com/payments/payment-element.md) in den [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;
```

Die unterstützten Optionen finden Sie in der [Stripe.js-Dokumentation](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options).

Sie können das [Erscheinungsbild aller Elemente anpassen](https://docs.stripe.com/payments/checkout/customization/appearance.md), indem Sie [elementsOptions.appearance](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions-appearance) an den [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider) übergeben.

## Zahlung übermitteln [Clientseitig]

#### HTML + JS

Zeigen Sie eine Schaltfläche **Bezahlen** an, die [confirm](https://docs.stripe.com/js/custom_checkout/confirm) von der `Checkout`-Instanz aufruft, um die Zahlung zu übermitteln.

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

Zeigen Sie eine Schaltfläche **Bezahlen** an, die zur [Bestätigung](https://docs.stripe.com/js/custom_checkout/confirm) von [useCheckoutElements](https://docs.stripe.com/js/react_stripe_js/checkout/use_checkout_elements) aufruft, um die Zahlung zu übermitteln.

```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;
```

## Ihre Integration testen

Um Ihre Integration zu testen, wählen Sie die Zahlungsmethode aus und tippen Sie auf **Bezahlen**. In einer *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) werden Sie auf eine Test-Zahlungsseite weitergeleitet, auf der Sie die Zahlung genehmigen oder ablehnen können.

Wenn Sie im Live-Modus auf **Bezahlen** tippen, werden Sie zur Website von Afterpay weitergeleitet. Mit Afterpay haben Sie keine Möglichkeit, die Zahlung zu genehmigen oder abzulehnen.


# Payment Intents API

> This is a Payment Intents API 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.

Informationen dazu, welche API den Anforderungen Ihres Unternehmens entspricht, finden Sie im [Vergleichsleitfaden](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md), um ein nutzerdefiniertes Stripe-Zahlungsformular in Ihre Website oder Anwendung einzubetten und Kundinnen und Kunden Zahlungsmethoden anzubieten. Erweiterte Konfigurationen und Anpassungen finden Sie im Integrationsleitfaden für die [Zahlungsannahme](https://docs.stripe.com/payments/accept-a-payment.md)

## Stripe einrichten [Serverseitig]

[Erstellen Sie ein Stripe-Konto](https://dashboard.stripe.com/register), um zu beginnen.

Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:

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

## Zahlungsdaten erfassen [Clientseitig]

Sie können nun mit dem Payment Element Zahlungsdetails auf dem Client erfassen. Das Payment Element ist eine vorgefertigte UI-Komponente, die die Erfassung von Zahlungsdaten für eine Vielzahl von Zahlungsmethoden vereinfacht.

Das Payment Element enthält einen iFrame, der Zahlungsinformationen über eine sichere HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da einige Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung voraussetzen.

Die Adresse der Bezahlseite muss mit `https://` und nicht `http://` beginnen, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, es zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren.

#### HTML + JS

### Stripe.js einrichten

Das Payment Element ist ein Feature von Stripe.js und steht damit automatisch zur Verfügung. Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es in den `head` Ihrer HTML-Datei einbinden. Laden Sie Stripe.js immer direkt von js.stripe.com, um die PCI-Konformität zu gewährleisten. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie selbst keine Kopie davon.

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

Erstellen Sie auf Ihrer Zahlungsseite eine Instanz von Stripe mit dem folgenden JavaScript:

```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>>');
```

### Payment Element zu Ihrer Checkout-Seite hinzufügen

Das Payment Element benötigt einen Platz auf Ihrer Checkout-Seite. Erstellen Sie einen leeren DOM-Knoten (Container) mit einer eindeutigen ID in Ihrem Zahlungsformular:

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

#### Zahlungsmethoden über das Dashboard steuern

Nachdem das obige Formular geladen wurde, erstellen Sie eine Elements-Instanz mit einem Wert für `mode`, `amount` und `currency`. Diese Werte bestimmen, welche Zahlungsmethoden Ihren Kundinnen/Kunden angezeigt werden. Um eine neue Zahlungsmethode in Ihrem Fomular anzugeben, müssen Sie sie unbedingt im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren.

```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');
```

#### Zahlungsmethoden manuell auflisten

Um die Zahlungsmethoden, die verfügbar sein sollen, manuell aufzulisten, fügen Sie jede einzelne zu den `paymentMethodTypes` hinzu.

Erstellen Sie dann eine Instanz des Payment Element und verbinden Sie sie mit dem Container DOM-Knoten.

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

### Stripe.js einrichten

Installieren Sie [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) und den [Stripe.js-Loader](https://www.npmjs.com/package/@stripe/stripe-js) aus dem öffentlichen npm-Register.

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

### Den Elements-Anbieter zu Ihrer Checkout-Seite hinzufügen und konfigurieren

Um die Payment Element-Komponente zu verwenden, schließen Sie die Komponente Ihrer Bezahlseite in einen [Elements-Anbieter](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider) ein. Rufen Sie `loadStripe` mit Ihrem veröffentlichbaren Schlüssel auf und übergeben Sie das zurückgegebene `Promise` an den `Elements`-Anbieter.

#### Zahlungsmethoden über das Dashboard steuern

Der `Elements`-Anbieter akzeptiert auch Werte für `mode`, `amount` und `currency`. Diese Werte bestimmen, welche Zahlungsmethoden Ihren Kundinnen/Kunden angezeigt werden. Um eine neue Zahlungsmethode in Ihrem Formular anzugeben, müssen Sie sie unbedingt im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren.

```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'));
```

#### Zahlungsmethoden manuell auflisten

```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'));
```

### Payment Element hinzufügen

Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen.

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

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

export default CheckoutForm;
```

Sie können das Payment Element an das Design Ihrer Website anpassen, indem Sie beim Erstellen des `Elements`-Anbieters das [Erscheinungs-Objekt](https://docs.stripe.com/elements/appearance-api.md) an `options` übergeben.

### Adressen einholen

Standardmäßig erfasst das Payment Element nur die erforderlichen Angaben zur Rechnungsadresse. Einige Verhaltensweisen, wie z. B. die [Berechnung der Steuer](https://docs.stripe.com/api/tax/calculations/create.md) oder die Eingabe der Versanddaten, erfordern die vollständige Adresse Ihrer Kundin/Ihres Kunden. Sie können Folgendes tun:

- Verwenden Sie das [Address Element](https://docs.stripe.com/elements/address-element.md), um die Vorteile der Funktionen der automatischen Vervollständigung und Lokalisierung zu nutzen, um die vollständige Adresse Ihrer Kundin oder Ihres Kunden zu erfassen. Dies trägt dazu bei, eine möglichst genaue Steuerberechnung zu gewährleisten.
- Erfassen Sie Adressdaten mit Ihrem eigenen benutzerdefinierten Formular.

## Einen PaymentIntent erstellen [Serverseitig]

> #### Benutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung ausführen
> 
> Navigieren Sie zu [Schritt&nbsp;5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) im Leitfaden zum Abschließen von Zahlungen, um Ihre nutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung auszuführen. Führen Sie andernfalls die folgenden Schritte für eine einfachere Integration aus, die `stripe.confirmPayment` auf dem Client verwendet, um die Zahlung zu bestätigen und alle nächsten Aktionen abzuwickeln.

#### Zahlungsmethoden über das Dashboard steuern

Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *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), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount` und einer `currency`. Um zu verhindern, dass böswillige Kundinnen/Kunden ihre eigenen Preise wählen, entscheiden Sie, wie viel Sie berechnen möchten, immer auf der Serverseite (einer vertrauenswürdigen Umgebung) und nicht auf dem Client.

Zu einem `PaymentIntent` gehört ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann.

#### Accounts&nbsp;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
```

#### Customers&nbsp;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
```

#### Zahlungsmethoden manuell auflisten

Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *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), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount`, einer `currency` und einer oder mehreren Zahlungsmethoden mithilfe von `payment_method_types`. Um zu verhindern, dass böswillige Kundinnen und Kunden ihre eigenen Preise wählen, sollten Sie den Preis immer auf der Serverseite (einer vertrauenswürdigen Umgebung) festlegen und nicht auf dem Client.

Zu einem PaymentIntent gehört ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann.

#### Accounts&nbsp;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
```

#### Customers&nbsp;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
```

## Zahlung an Stripe senden [Clientseitig]

Verwenden Sie [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment), um die Zahlung mit den Angaben aus dem Payment Element abzuschließen.

Geben Sie eine [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) für diese Funktion an, um anzugeben, wohin Stripe den/die Nutzer/in nach Abschluss der Zahlung weiterleitet. Ihre Nutzer/innen werden möglicherweise zunächst an eine Zwischenwebsite, z. B. eine Bankautorisierungsseite, weitergeleitet, bevor sie zur `return_url` weitergeleitet werden. Bei Kartenzahlungen erfolgt die Weiterleitung zur `return_url` sofort, wenn eine Zahlung erfolgreich ist.

Wenn Sie bei Kartenzahlungen nach Abschluss der Zahlung keine Weiterleitung wünschen, können Sie [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) auf `if_required` festlegen. Dadurch werden nur Kundinnen/Kunden weitergeleitet, die mit auf Weiterleitung basierenden Zahlungsmethoden bezahlen.

#### 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: Ereignisse nach Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

- **Manuelles Bearbeiten von Ereignissen im Dashboard**

  Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen.

- **Erstellen eines benutzerdefinierten Webhooks**

  Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der Stripe CLI.

- **Integrieren einer vorgefertigten App**

  Bearbeiten Sie häufige Unternehmensereignisse, wie z.&nbsp;B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.

## Optional: Separate Autorisierung und Erfassung

Sie können Autorisierung und Erfassung trennen, um eine Zahlung sofort zu erstellen, Gelder jedoch später zu erfassen. Stripe storniert den PaymentIntent und sendet das Ereignis [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled), wenn die Zahlung nicht während des 7-tägigen Zeitfensters erfasst wird.

Wenn Sie wissen, dass Sie die Zahlung nicht erfassen können, empfehlen wir, [den PaymentIntent zu stornieren](https://docs.stripe.com/refunds.md#cancel-payment), anstatt zu warten, bis das Zeitfenster von 7&nbsp;Tagen abgelaufen ist.

### Stripe anweisen, nur die Autorisierung durchzuführen

Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag auf dem Afterpay-Konto der Kundin/des Kunden zu autorisieren.

```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"
```

### Die Gelder erfassen

Nach erfolgreicher Autorisierung wechselt der [Status des PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine [Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) für den PaymentIntent durch.

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

Stripe erfasst standardmäßig den autorisierten Gesamtbetrag. Sie können auch angeben, dass `amount_to_capture` kleiner oder gleich der Summe sein soll.

### (Optional) Autorisierung stornieren

Wenn Sie eine Autorisierung stornieren müssen, können Sie [den PaymentIntent stornieren](https://docs.stripe.com/api/payment_intents/cancel.md).

## Ihre Integration testen

Um Ihre Integration zu testen, wählen Sie die Zahlungsmethode aus und tippen Sie auf **Bezahlen**. In einer *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) werden Sie auf eine Test-Zahlungsseite weitergeleitet, auf der Sie die Zahlung genehmigen oder ablehnen können.

Wenn Sie im Live-Modus auf **Bezahlen** tippen, werden Sie zur Website von Afterpay weitergeleitet. Mit Afterpay haben Sie keine Möglichkeit, die Zahlung zu genehmigen oder abzulehnen.

## Fehlercodes

In der folgenden Tabelle finden Sie häufige Fehlercodes und die empfohlenen Maßnahmen:

| Fehlercode                                                | Empfohlene Maßnahme                                                                                                                                                                                                                                                                                                                                                                                      |
| --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_invalid_currency`                         | Geben Sie eine unterstützte Währung ein.                                                                                                                                                                                                                                                                                                                                                                 |
| `missing_required_parameter`                              | In der Fehlermeldung erhalten Sie weitere Informationen zum erforderlichen Parameter.                                                                                                                                                                                                                                                                                                                    |
| `payment_intent_payment_attempt_failed`                   | Dieser Code kann im Feld [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) eines PaymentIntent angezeigt werden. Eine genauere Fehlerursache und Vorschläge zur Fehlerbehebung finden Sie in der Fehlermeldung.                                                                                                             |
| `payment_intent_authentication_failure`                   | Dieser Code kann im Feld [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) eines PaymentIntent erscheinen. Prüfen Sie die Fehlermeldung für einen detaillierten Grund des Fehlers und Hinweise zur Fehlerbehandlung. Dieser Fehler tritt auf, wenn Sie während des Testens Ihrer Integration manuell einen Fehler auslösen. |
| `payment_intent_redirect_confirmation_without_return_url` | Geben Sie eine `return_url` an, wenn Sie einen PaymentIntent bestätigen.                                                                                                                                                                                                                                                                                                                                 |


> Der Inhalt dieses Abschnitts bezieht sich auf ein *Legacy* (Technology that's no longer recommended)-Produkt. Verwenden Sie den Leitfaden [Zahlungen akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md) für den aktuellsten Integrationspfad. Auch wenn Stripe dieses Produkt jetzt noch unterstützt, kann sich dies ändern, wenn das Produkt nicht mehr unterstützt wird.

Stripe-Nutzer/innen können die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md)&nbsp;– einen zentralen Integrationspfad für die Erstellung von Zahlungen mit einer beliebigen unterstützten Methode&nbsp;– verwenden, um Zahlungen per [Afterpay](https://www.afterpay.com/) von Kundinnen und Kunden aus folgenden Ländern anzunehmen:

- Australien
- Kanada
- Neuseeland
- Vereinigtes Königreich
- Vereinigte Staaten

Afterpay ist eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage) mit [sofortiger Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification), bei der Kundinnen/Kunden ihre Zahlung [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Kundinnen/Kunden werden auf die Afterpay-Website weitergeleitet, wo sie den Bedingungen eines Ratenzahlungsvertrags zustimmen. Wenn die Kundinnen/Kunden die Bedingungen akzeptieren, werden die Gelder garantiert und auf Ihr Stripe-Konto überwiesen. Die Kundinnen/Kunden zahlen die Zahlung über eine gewissen Zeitraum direkt an Afterpay zurück.

> Bevor Sie mit der Integration beginnen, vergewissern Sie sich, dass Ihr Konto für Afterpay geeignet ist. Dies können Sie in Ihren [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) prüfen.

## Stripe einrichten [Serverseitig]

Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register).

Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:

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

## PaymentIntent erstellen [Serverseitig]

Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht, eine Kundenzahlung einzuziehen, darstellt und den gesamten Zahlungsvorgang dokumentiert. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag sowie eine unterstützte Währung an. Wenn Sie bereits eine Integration mit dem [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) haben, fügen Sie `afterpay_clearpay` zur Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren `PaymentIntent` hinzu.

Sie können Zahlungsmethoden über das [Dashboard](https://dashboard.stripe.com/settings/payment_methods) verwalten. Stripe handhabt die Rückgabe der in Frage kommenden Zahlungsmethoden basierend auf Faktoren wie dem Betrag und der Währung der Transaktion und dem Zahlungsablauf. Im folgenden Beispiel wird das Attribut [automatic_payment_methods](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-automatic_payment_methods-enabled) verwendet. Sie können jedoch auch `afterpay_clearpay` mit [Arten von Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) auflisten. In der neuesten Version der API ist die Angabe des Parameters `automatic_payment_methods` optional, da Stripe seine Funktionalität standardmäßig aktiviert. Unabhängig von der gewählten Option müssen Sie unbedingt Afterpay Clearpay im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren.

```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"
```

### Client-Geheimnis abrufen

Im PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, das auf dem Client verwendet wird, um Zahlungen sicher abzuschließen. Es gibt verschiedene Verfahren zum Übergeben des Client-Geheimnisses an den Client.

#### Einseitige Anwendung

Rufen Sie das Client-Geheimnis von einem Endpoint auf Ihrem Server ab, indem Sie die Browser-Funktion `fetch` verwenden. Diese Vorgehensweise funktioniert am besten, wenn es sich bei Ihrer Client-Seite um eine einseitige Anwendung handelt, insbesondere wenn sie mit einem modernen Frontend-Framework wie React erstellt wurde. Erstellen Sie den Server-Endpoint, der das Client-Geheimnis bereitstellt:

#### Ruby

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

Und dann rufen Sie das Client-Geheimnis mit JavaScript auf der Client-Seite ab:

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

#### Serverseitiges Rendering

Übergeben Sie das Client-Geheimnis von Ihrem Server an den Client. Diese Vorgehensweise funktioniert am besten, wenn Ihre Anwendung statische Inhalte auf dem Server generiert, bevor sie an den Browser gesendet werden.

Fügen Sie das [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) in Ihr Bezahlformular ein. Rufen Sie in Ihrem serverseitigen Code das Client-Geheimnis aus dem PaymentIntent ab:

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

### Zahlungserfolgsquoten mit zusätzlichen Details verbessern

Übermitteln Sie optional [Versanddetails](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-shipping), um die Konversionsraten zu verbessern. Bei dieser Integration werden Versanddetails vom Kunden/der Kundin übergeben, nachdem er/sie eine Zahlungsmethode ausgewählt hat.

Wenn Sie eine Versandadresse senden, muss diese gültige Werte für `line1`, `city`, `state`, `postal_code` und `country` enthalten.

### Zusätzliche Optionen für Zahlungsmethoden

Sie können in den [Optionen für Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) für Ihren `PaymentIntent` einen optionalen `Referenz`-Parameter angeben, der eine interne Bestell-Identifikationsnummer für die Zahlung festlegt. Diese ist in der Regel weder für das Unternehmen noch für den/die Verbraucher/in sichtbar, doch das interne Support-Team von Afterpay kann bei manuellen Support-Anfragen darauf zugreifen. Die Identifikationsnummer ist auf 128 Zeichen beschränkt und darf nur Buchstaben, Ziffern, Unterstriche, Schrägstriche und Bindestriche enthalten.

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

## Zahlung an Stripe senden [Clientseitig]

In diesem Schritt führen Sie Afterpay-Zahlungen auf dem Client mit [Stripe.js](https://docs.stripe.com/payments/elements.md) durch.

### Stripe.js einrichten

Wenn Kund/innen über das „Click to Pay“-Verfahren mit Afterpay bezahlen, empfehlen wir die Verwendung von Stripe.js, um die Zahlungen an Stripe zu übermitteln. Stripe.js ist unsere grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie verarbeitet automatisch komplexe Szenarien wie die nachfolgend beschriebene Weiterleitung und ermöglicht die unkomplizierte Erweiterung Ihrer Integration durch weitere Zahlungsmethoden in der Zukunft. Binden Sie das Stripe.js-Skript in Ihre Bezahlseite ein, indem Sie es zum Header der HTML-Datei hinzufügen.

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

Erstellen Sie auf Ihrer Bezahlseite eine Instanz von Stripe.js mit dem folgenden JavaScript.

```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>>',
);
```

Anstatt das gesamte PaymentIntent.Objekt an den Client zu senden, verwenden Sie dessen [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus [Schritt&nbsp;2](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#web-create-payment-intent). Dies unterscheidet sich von Ihren API-Schlüsseln, die API-Anfragen von Stripe authentifizieren.

Achten Sie dennoch auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Zahlung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden.

Verwenden Sie [stripe.confirmAfterpayClearpayPayment](https://docs.stripe.com/js/payment_intents/confirm_afterpay_clearpay_payment), um die Weiterleitung von Ihrer Seite zu verarbeiten und die Zahlung abzuschließen. Fügen Sie dieser Funktion eine [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) hinzu, um anzugeben, wohin Stripe Nutzer/innen weiterleitet, nachdem sie die Zahlung auf der Website oder in der App ihrer Bank durchgeführt haben.

```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.
}
```

Wenn Ihr Kunde/Ihre Kundin eine Zahlung übermittelt, leitet Stripe ihn an die `return_url` weiter und fügt die folgenden URL-Abfrageparameter ein. Die Rückgabeseite kann diese nutzen, um den Status des PaymentIntent abzurufen, damit der Kunde/die Kundin den Zahlungsstatus anzeigen kann.

Wenn Sie die `return_url` angeben, können Sie auch Ihre eigenen Abfrageparameter für die Verwendung auf der Rückgabeseite anhängen.

| Parameter                      | Beschreibung                                                                                                                                                                                                                                                                                                                                                   |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent`               | Die eindeutige ID für den `PaymentIntent`.                                                                                                                                                                                                                                                                                                                     |
| `payment_intent_client_secret` | Das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent`-Objekts. Bei Abonnementintegrationen wird dieses client_secret auch über [`confirmation_secret`](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) im `Invoice`-Objekt sichtbar gemacht |

Wenn Kundinnen und Kunden auf Ihre Seite weitergeleitet werden, können Sie `payment_intent_client_secret` nutzen, um den PaymentIntent abzufragen und Ihren Kundinnen und Kunden den Transaktionsstatus anzuzeigen.

## Optional: Posten zum PaymentIntent hinzufügen

Sie haben die Möglichkeit, Einzelpostendaten zu akzeptieren, um Afterpay weitere Risikosignale zu liefern. Diese Funktion befindet sich derzeit in der privaten Beta-Phase. Bitte kontaktieren Sie uns über das Formular im [Stripe-Support](https://support.stripe.com), wenn Sie Zugang beantragen möchten.

## Optional: Separate Autorisierung und Erfassung

Anders als bei der [getrennten Autorisierung und Erfassung für Kartenzahlungen](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) belastet Afterpay die Kundin/den Kunden mit der ersten Rate der Zahlung zum Zeitpunkt der Autorisierung. Sie haben dann nach der Autorisierung maximal 13&nbsp;Tage Zeit, den Rest der Zahlung zu erfassen. Wenn Sie die Zahlung in diesem Zeitfenster nicht erfassen, erhält der Kunde/die Kundin eine Rückerstattung für diese Rate und ihm/ihr werden keine weiteren Raten berechnet. Der Kundin/Dem Kunden werden dann keine weiteren Raten mehr in Rechnung gestellt. In diesen Fällen storniert Stripe außerdem den PaymentIntent und übermittelt das Ereignis [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Wenn Sie wissen, dass Sie die Zahlung nicht erfassen können, sollten Sie [den PaymentIntent stornieren](https://docs.stripe.com/refunds.md#cancel-payment) und nicht warten, bis das Zeitfenster von 13&nbsp;Tagen abgelaufen ist. Durch die proaktive Stornierung des PaymentIntent wird die erste Rate sofort an die Kundin/den Kunden zurückerstattet, sodass keine Verwirrung hinsichtlich der Zahlungen in ihrer Abrechnung entsteht.

### Stripe anweisen, nur die Autorisierung durchzuführen

Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag auf dem Afterpay-Konto der Kundin/des Kunden zu autorisieren.

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

Bei erfolgreicher Autorisierung übermittelt Stripe das Ereignis [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Lesen Sie in unserem [Leitfaden zu Ereignissen](https://docs.stripe.com/api/events.md) mehr dazu.

### Die Gelder erfassen

Nach erfolgreicher Autorisierung wechselt der [Status](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) des PaymentIntent zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine PaymentIntent-[Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) durch. Standardmäßig wird der gesamte autorisierte Betrag erfasst. Sie können keinen höheren, aber einen niedrigeren Betrag erfassen.

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

### (Optional) Autorisierung stornieren

Wenn Sie eine Autorisierung stornieren müssen, können Sie den [PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) stornieren.

## Optional: Afterpay-Weiterleitung manuell verarbeiten

Wir empfehlen, die Abwicklung von Afterpay-Weiterleitungen und -Zahlungen auf Client-Seite mit `confirmAfterpayClearpayPayment` Stripe.js zu überlassen. Wenn Sie Stripe.js verwenden, können Sie Ihre Integration um weitere Zahlungsmethoden erweitern. Sie können Ihre Kundinnen/Kunden jedoch mit den folgenden Schritten auch manuell an Ihren Server weiterleiten:

- Erstellen und bestätigen Sie einen [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) vom Typ `afterpay_clearpay`. Sie müssen die Eigenschaft `payment_method_data.billing_details` angeben, die von Afterpay benötigt wird. `payment_intent.shipping` ist optional, wird jedoch empfohlen, um die Authentifizierungsraten zu verbessern. Durch Angabe von `payment_method_data` erstellt Stripe eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) und verwendet sie sofort mit diesem PaymentIntent.

  Sie müssen außerdem im Feld `return_url` die Weiterleitungs-URL angeben, an die Ihre Kund/innen weitergeleitet werden, nachdem sie ihre Zahlung abgeschlossen haben. Darüber hinaus können Sie in dieser URL Ihre eigenen Abfrageparameter übergeben. Diese Parameter sind bei Abschluss des Weiterleitungsablaufs in der endgültigen URL enthalten.

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

  Der erstellte `PaymentIntent` hat den Status `requires_action`, und der Typ für `next_action` ist `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"
    ]
  }
  ```

- Leiten Sie die Kund/innen an die in der Eigenschaft `next_action.redirect_to_url.url` angegebene URL weiter. Das folgende Codebeispiel ist nur eine Annäherung und kann sich vom Weiterleitungsverfahren in Ihrem Web-Framework unterscheiden.

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

Bei Abschluss des Authentifizierungsvorgangs werden Kundinnen/Kunden an die in Schritt 1 konfigurierte `return_url` weitergeleitet. Die URL-Abfrageparameter `payment_intent` und `payment_intent_client_secret` sind enthalten, und Sie können Ihre eigenen Abfrageparameter übergeben, wie oben beschrieben.

Wir empfehlen die Verwendung von [Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um den Zahlungsstatus zu bestätigen.

## Optional: Ereignisse nach Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

- **Manuelles Bearbeiten von Ereignissen im Dashboard**

  Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen.

- **Erstellen eines benutzerdefinierten Webhooks**

  Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der Stripe CLI.

- **Integrieren einer vorgefertigten App**

  Bearbeiten Sie häufige Unternehmensereignisse, wie z.&nbsp;B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.

## Optional: Afterpay-Integration testen

Testen Sie Ihre Afterpay-Integration mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`.

Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`.

Für die [manuelle Erfassung](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) von PaymentIntents im Testmodus läuft der nicht erfasste PaymentIntent 10 Minuten nach erfolgreicher Autorisierung automatisch ab.

## Optional: Mitteilungen zur Zahlungsmethode auf Ihrer Website anzeigen

Das [Payment Method Messaging Element](https://docs.stripe.com/js/elements_object/create_element?type=paymentMethodMessaging) ist eine integrierbare Komponente der Nutzeroberfläche, die Ihre Kundinnen/Kunden direkt auf Ihren Produkt-, Warenkorb- oder Zahlungsseiten darüber informiert, welche „Jetzt kaufen, später bezahlen“-Zahlungsoptionen ihnen beim Bezahlvorgang zur Verfügung stehen.

Informationen zum Hinzufügen des Payment Method Messaging Element zu Ihrer Website finden Sie unter [Payment Method Messaging anzeigen](https://docs.stripe.com/elements/payment-method-messaging.md).

## Fehlgeschlagene Zahlungen

Afterpay berücksichtigt mehrere Faktoren bei der Entscheidung, ob eine Transaktion akzeptiert oder abgelehnt wird (zum Beispiel die Dauer der Nutzung von Afterpay durch den/die Käufer/in, den ausstehenden Betrag, den der/die Kund/in zurückzahlen muss, oder den Wert der aktuellen Bestellung).

Sie sollten in Ihrem Bezahlvorgang immer weitere Zahlungsoptionen wie `card` anbieten, da Afterpay-Zahlungen eine höhere Ablehnungsrate haben als viele andere Zahlungsmethoden. In diesen Fällen wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Bei einem Afterpay-[PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) mit dem Status `requires_action` müssen Kundinnen/Kunden die Zahlung innerhalb von 3&nbsp;Stunden nach Weiterleitung zur Afterpay-Website abschließen. Wenn nach 3&nbsp;Stunden keine Aktion erfolgt ist, wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt, und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Teilen Sie Ihren Kund/innen in diesen Fällen mit, dass sie es mit einer anderen Zahlungsoption versuchen sollten, die in Ihrem Bezahlvorgang zur Verfügung gestellt wird.

## Fehlercodes

Im Folgenden finden Sie die häufigsten Fehlercodes und die entsprechenden empfohlenen Maßnahmen:

| Fehlercode                               | Empfohlene Maßnahme                                                                                                                                                                                                                                                                          |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Ein allgemeiner Fehler, der darauf hinweist, dass der Afterpay-Bezahlvorgang fehlgeschlagen ist. Es kann sich auch um eine abgelehnte Zahlung handeln, die nicht als Fehlercode für abgelehnte Zahlungen angezeigt wird.                                                                     |
| `payment_method_provider_decline`        | Afterpay hat die Kundenzahlung abgelehnt. Als nächsten Schritt muss sich der Kunde/die Kundin an Afterpay wenden, um weitere Informationen einzuholen.                                                                                                                                       |
| `payment_intent_payment_attempt_expired` | Die Kundin/der Kunde hat die Zahlung auf der Afterpay-Checkout-Seite nicht abgeschlossen und die Payment-Sitzung ist abgelaufen. Stripe setzt PaymentIntents, die nicht erfolgreich autorisiert wurden, automatisch 3&nbsp;Stunden nach Erstellung des ursprünglichen Checkouts außer Kraft. |
| `payment_method_not_available`           | Bei Afterpay ist ein Servicefehler aufgetreten und die Anfrage kann nicht abgeschlossen werden. Versuchen Sie es zu einem späteren Zeitpunkt erneut.                                                                                                                                         |
| `amount_too_small`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |
| `amount_too_large`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |

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

Wenn Ihre App Afterpay akzeptiert, wird Kund/innen für die Authentifizierung der Zahlung eine Webansicht angezeigt. Anschließend kehrt der/die Kund/in zu Ihrer App zurück und Sie können sofort *bestätigen* (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), ob die Zahlung erfolgreich war oder fehlgeschlagen ist.

> Bevor Sie mit der Integration beginnen, vergewissern Sie sich, dass Ihr Konto für Afterpay geeignet ist. Dies können Sie in Ihren [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) prüfen.

## Stripe einrichten [Serverseitig] [Clientseitig]

Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register).

### Serverseitig

Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie die offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Clientseitig

Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13 oder höher unterstützen.

#### Swift Package Manager

Führen Sie zur Installation des SDK die folgenden Schritte aus:

1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein.
1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus.
1. Fügen Sie das Produkt **StripePaymentsUI** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu.

#### CocoaPods

1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen:
   ```bash
   pod init
   ```
1. Fügen Sie folgende Zeile in Ihre `Podfile` ein:
   ```podfile
   pod 'StripePaymentsUI'
   ```
1. Führen Sie folgenden Befehl aus:
   ```bash
   pod install
   ```
1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden.
1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus:
   ```bash
   pod update StripePaymentsUI
   ```

#### Carthage

1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein:
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks einbetten.
1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus:
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### Manuelles Framework

1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei.
1. Ziehen Sie **StripePaymentsUI.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig).
1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks.
1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3.

> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).

Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/test/apikeys) von Stripe, um es beim Start der App auszuführen. Dadurch kann Ihre App Anfragen an die Stripe-API senden.

#### Swift

```swift
import UIKitimportStripePaymentsUI

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

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

> Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App.

## PaymentIntent erstellen [Serverseitig] [Clientseitig]

Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht, eine Kundenzahlung einzuziehen, darstellt und den gesamten Zahlungsvorgang dokumentiert.

### Serverseitig

Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag sowie eine unterstützte Währung an. Wenn Sie bereits eine Integration mit dem [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) haben, fügen Sie `afterpay_clearpay` zur Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren `PaymentIntent` hinzu.

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

### Zusätzliche Optionen für Zahlungsmethoden

Sie können in den [Optionen für Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) für Ihren `PaymentIntent` einen optionalen `Referenz`-Parameter angeben, der eine interne Bestell-Identifikationsnummer für die Zahlung festlegt. Diese ist in der Regel weder für das Unternehmen noch für den/die Verbraucher/in sichtbar, doch das interne Support-Team von Afterpay kann bei manuellen Support-Anfragen darauf zugreifen. Die Identifikationsnummer ist auf 128 Zeichen beschränkt und darf nur Buchstaben, Ziffern, Unterstriche, Schrägstriche und Bindestriche enthalten.

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

### Clientseitig

Im zurückgegebenen PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, mit dem der Client den Zahlungsvorgang sicher abschließen kann, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie das zugehörige Client-Geheimnis.

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

## Angaben zur Zahlungsmethode erfassen [Clientseitig]

Für Afterpay sind die Abrechnungsdaten erforderlich, damit die Zahlung durchgeführt werden kann. Erfassen Sie in Ihrer App die erforderlichen Abrechnungsdaten von den Kundinnen/Kunden:

- Vollständiger Name (Vor- und Nachname)
- E-Mail-Adresse
- Vollständige Rechnungsadresse

Erstellen Sie ein [STPPaymentMethodParams](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentMethodParams.html)-Objekt mit diesen Angaben.

Auch wenn keine Versanddaten erforderlich sind, können Sie die Authentifizierungsraten verbessern. Um Versanddaten zu erfassen, erfassen Sie folgende Daten von der Kundin/dem Kunden:

- Vollständiger Name
- Vollständige Versandadresse

Erstellen Sie ein [STPPaymentIntentShippingDetailsAddressParams](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentIntentShippingDetailsAddressParams.html)-Objekt mit diesen Angaben.

#### 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")
```

## Zahlung an Stripe senden [Clientseitig]

Rufen Sie das Client-Geheimnis von dem in Schritt 2 erstellten PaymentIntent ab und rufen Sie die [STPPaymentHandler confirmPayment:](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:)-Methode auf. Dies entspricht einer Webansicht, in der die Kundinnen und Kunden ihre Zahlung abschließen können. Anschließend wird der Completion-Block mit dem Ergebnis der Zahlung aufgerufen.

#### 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: Posten zum PaymentIntent hinzufügen

Sie haben die Möglichkeit, Einzelpostendaten zu akzeptieren, um Afterpay weitere Risikosignale zu liefern. Diese Funktion befindet sich derzeit in der privaten Beta-Phase. Bitte kontaktieren Sie uns über das Formular im [Stripe-Support](https://support.stripe.com), wenn Sie Zugang beantragen möchten.

## Optional: Separate Autorisierung und Erfassung

Anders als bei der [getrennten Autorisierung und Erfassung für Kartenzahlungen](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) belastet Afterpay die Kundin/den Kunden mit der ersten Rate der Zahlung zum Zeitpunkt der Autorisierung. Sie haben dann nach der Autorisierung maximal 13&nbsp;Tage Zeit, den Rest der Zahlung zu erfassen. Wenn Sie die Zahlung in diesem Zeitfenster nicht erfassen, erhält der Kunde/die Kundin eine Rückerstattung für diese Rate und ihm/ihr werden keine weiteren Raten berechnet. Der Kundin/Dem Kunden werden dann keine weiteren Raten mehr in Rechnung gestellt. In diesen Fällen storniert Stripe außerdem den PaymentIntent und übermittelt das Ereignis [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Wenn Sie wissen, dass Sie die Zahlung nicht erfassen können, sollten Sie [den PaymentIntent stornieren](https://docs.stripe.com/refunds.md#cancel-payment) und nicht warten, bis das Zeitfenster von 13&nbsp;Tagen abgelaufen ist. Durch die proaktive Stornierung des PaymentIntent wird die erste Rate sofort an die Kundin/den Kunden zurückerstattet, sodass keine Verwirrung hinsichtlich der Zahlungen in ihrer Abrechnung entsteht.

### Stripe anweisen, nur die Autorisierung durchzuführen

Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag auf dem Afterpay-Konto der Kundin/des Kunden zu autorisieren.

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

Bei erfolgreicher Autorisierung übermittelt Stripe das Ereignis [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Lesen Sie in unserem [Leitfaden zu Ereignissen](https://docs.stripe.com/api/events.md) mehr dazu.

### Die Gelder erfassen

Nach erfolgreicher Autorisierung wechselt der [Status](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) des PaymentIntent zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine PaymentIntent-[Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) durch. Standardmäßig wird der gesamte autorisierte Betrag erfasst. Sie können keinen höheren, aber einen niedrigeren Betrag erfassen.

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

### (Optional) Autorisierung stornieren

Wenn Sie eine Autorisierung stornieren müssen, können Sie den [PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) stornieren.

## Optional: Ereignisse nach Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

- **Manuelles Bearbeiten von Ereignissen im Dashboard**

  Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen.

- **Erstellen eines benutzerdefinierten Webhooks**

  Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der Stripe CLI.

- **Integrieren einer vorgefertigten App**

  Bearbeiten Sie häufige Unternehmensereignisse, wie z.&nbsp;B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.

## Optional: Afterpay-Integration testen

Testen Sie Ihre Afterpay-Integration mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`.

Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`.

Für die [manuelle Erfassung](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) von PaymentIntents im Testmodus läuft der nicht erfasste PaymentIntent 10 Minuten nach erfolgreicher Autorisierung automatisch ab.

## Fehlgeschlagene Zahlungen

Afterpay berücksichtigt mehrere Faktoren bei der Entscheidung, ob eine Transaktion akzeptiert oder abgelehnt wird (zum Beispiel die Dauer der Nutzung von Afterpay durch den/die Käufer/in, den ausstehenden Betrag, den der/die Kund/in zurückzahlen muss, oder den Wert der aktuellen Bestellung).

Sie sollten in Ihrem Bezahlvorgang immer weitere Zahlungsoptionen wie `card` anbieten, da Afterpay-Zahlungen eine höhere Ablehnungsrate haben als viele andere Zahlungsmethoden. In diesen Fällen wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Bei einem Afterpay-[PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) mit dem Status `requires_action` müssen Kundinnen/Kunden die Zahlung innerhalb von 3&nbsp;Stunden nach Weiterleitung zur Afterpay-Website abschließen. Wenn nach 3&nbsp;Stunden keine Aktion erfolgt ist, wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt, und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Teilen Sie Ihren Kund/innen in diesen Fällen mit, dass sie es mit einer anderen Zahlungsoption versuchen sollten, die in Ihrem Bezahlvorgang zur Verfügung gestellt wird.

## Fehlercodes

Im Folgenden finden Sie die häufigsten Fehlercodes und die entsprechenden empfohlenen Maßnahmen:

| Fehlercode                               | Empfohlene Maßnahme                                                                                                                                                                                                                                                                          |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Ein allgemeiner Fehler, der darauf hinweist, dass der Afterpay-Bezahlvorgang fehlgeschlagen ist. Es kann sich auch um eine abgelehnte Zahlung handeln, die nicht als Fehlercode für abgelehnte Zahlungen angezeigt wird.                                                                     |
| `payment_method_provider_decline`        | Afterpay hat die Kundenzahlung abgelehnt. Als nächsten Schritt muss sich der Kunde/die Kundin an Afterpay wenden, um weitere Informationen einzuholen.                                                                                                                                       |
| `payment_intent_payment_attempt_expired` | Die Kundin/der Kunde hat die Zahlung auf der Afterpay-Checkout-Seite nicht abgeschlossen und die Payment-Sitzung ist abgelaufen. Stripe setzt PaymentIntents, die nicht erfolgreich autorisiert wurden, automatisch 3&nbsp;Stunden nach Erstellung des ursprünglichen Checkouts außer Kraft. |
| `payment_method_not_available`           | Bei Afterpay ist ein Servicefehler aufgetreten und die Anfrage kann nicht abgeschlossen werden. Versuchen Sie es zu einem späteren Zeitpunkt erneut.                                                                                                                                         |
| `amount_too_small`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |
| `amount_too_large`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |


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

Wenn Ihre App Afterpay akzeptiert, wird Kund/innen für die Authentifizierung der Zahlung eine Webansicht angezeigt. Anschließend kehrt der/die Kund/in zu Ihrer App zurück und Sie können sofort *bestätigen* (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), ob die Zahlung erfolgreich war oder fehlgeschlagen ist.

> Bevor Sie mit der Integration beginnen, vergewissern Sie sich, dass Ihr Konto für Afterpay geeignet ist. Dies können Sie in Ihren [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) prüfen.

## Stripe einrichten [Serverseitig] [Clientseitig]

Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register).

### Serverseitig

Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie diese offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Clientseitig

Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/).

Um das SDK zu installieren, fügen Sie `stripe-android` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein:

#### Kotlin

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

android { ... }

dependencies {
  // ...

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

> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).

Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/apikeys) von Stripe so, dass dieser Anfragen an die API stellen kann, wie beispielsweise in Ihrer Unterklasse `Application`:

#### Kotlin

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

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

> Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App.

Stripe-Beispiele nutzen auch [OkHttp](https://github.com/square/okhttp) und [GSON](https://github.com/google/gson), um HTTP-Anfragen an einen Server zu stellen.

## PaymentIntent erstellen [Serverseitig] [Clientseitig]

Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht, eine Kundenzahlung einzuziehen, darstellt und den gesamten Zahlungsvorgang dokumentiert.

### Serverseitig

Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag sowie eine unterstützte Währung an. Wenn Sie bereits eine Integration mit dem [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) haben, fügen Sie `afterpay_clearpay` zur Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren `PaymentIntent` hinzu.

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

### Zusätzliche Optionen für Zahlungsmethoden

Sie können in den [Optionen für Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-afterpay_clearpay-reference) für Ihren `PaymentIntent` einen optionalen `Referenz`-Parameter angeben, der eine interne Bestell-Identifikationsnummer für die Zahlung festlegt. Diese ist in der Regel weder für das Unternehmen noch für den/die Verbraucher/in sichtbar, doch das interne Support-Team von Afterpay kann bei manuellen Support-Anfragen darauf zugreifen. Die Identifikationsnummer ist auf 128 Zeichen beschränkt und darf nur Buchstaben, Ziffern, Unterstriche, Schrägstriche und Bindestriche enthalten.

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

### Clientseitig

Im zurückgegebenen PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, mit dem der Client den Zahlungsvorgang sicher abschließen kann, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie das zugehörige Client-Geheimnis.

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

## Angaben zur Zahlungsmethode erfassen [Clientseitig]

Für Afterpay sind die Abrechnungsdaten erforderlich, damit die Zahlung durchgeführt werden kann. Erfassen Sie in Ihrer App die erforderlichen Abrechnungsdaten von den Kundinnen/Kunden:

- Vollständiger Name (Vor- und Nachname)
- E-Mail-Adresse
- Vollständige Rechnungsadresse

Erstellen Sie mit diesen Angaben ein [PaymentMethodCreateParams](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-payment-method-create-params/index.html)-Modell.

Auch wenn keine Versanddaten erforderlich sind, können Sie die Authentifizierungsraten verbessern. Um Versanddaten zu erfassen, erfassen Sie folgende Daten von der Kundin/dem Kunden:

- Vollständiger Name
- Vollständige Versandadresse

Erstellen Sie mit diesen Angaben ein [ConfirmPaymentIntentParams.Shipping](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-confirm-payment-intent-params/-shipping/index.html)-Modell.

#### 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()
)
```

## Zahlung an Stripe senden [Clientseitig]

Rufen Sie das Client-Geheimnis von dem in Schritt 2 erstellten PaymentIntent ab und rufen Sie die Methode [PaymentLauncher bestätigen](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690) auf. Dies entspricht einer Webansicht, in der die Kundinnen und Kunden die Zahlung auf der Website oder in der App ihrer Bank durchführen können. Anschließend wird onActivityResult mit dem Ergebnis der Zahlung aufgerufen.

#### 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: Posten zum PaymentIntent hinzufügen

Sie haben die Möglichkeit, Einzelpostendaten zu akzeptieren, um Afterpay weitere Risikosignale zu liefern. Diese Funktion befindet sich derzeit in der privaten Beta-Phase. Bitte kontaktieren Sie uns über das Formular im [Stripe-Support](https://support.stripe.com), wenn Sie Zugang beantragen möchten.

## Optional: Separate Autorisierung und Erfassung

Anders als bei der [getrennten Autorisierung und Erfassung für Kartenzahlungen](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) belastet Afterpay die Kundin/den Kunden mit der ersten Rate der Zahlung zum Zeitpunkt der Autorisierung. Sie haben dann nach der Autorisierung maximal 13&nbsp;Tage Zeit, den Rest der Zahlung zu erfassen. Wenn Sie die Zahlung in diesem Zeitfenster nicht erfassen, erhält der Kunde/die Kundin eine Rückerstattung für diese Rate und ihm/ihr werden keine weiteren Raten berechnet. Der Kundin/Dem Kunden werden dann keine weiteren Raten mehr in Rechnung gestellt. In diesen Fällen storniert Stripe außerdem den PaymentIntent und übermittelt das Ereignis [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Wenn Sie wissen, dass Sie die Zahlung nicht erfassen können, sollten Sie [den PaymentIntent stornieren](https://docs.stripe.com/refunds.md#cancel-payment) und nicht warten, bis das Zeitfenster von 13&nbsp;Tagen abgelaufen ist. Durch die proaktive Stornierung des PaymentIntent wird die erste Rate sofort an die Kundin/den Kunden zurückerstattet, sodass keine Verwirrung hinsichtlich der Zahlungen in ihrer Abrechnung entsteht.

### Stripe anweisen, nur die Autorisierung durchzuführen

Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag auf dem Afterpay-Konto der Kundin/des Kunden zu autorisieren.

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

Bei erfolgreicher Autorisierung übermittelt Stripe das Ereignis [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Lesen Sie in unserem [Leitfaden zu Ereignissen](https://docs.stripe.com/api/events.md) mehr dazu.

### Die Gelder erfassen

Nach erfolgreicher Autorisierung wechselt der [Status](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) des PaymentIntent zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine PaymentIntent-[Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) durch. Standardmäßig wird der gesamte autorisierte Betrag erfasst. Sie können keinen höheren, aber einen niedrigeren Betrag erfassen.

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

### (Optional) Autorisierung stornieren

Wenn Sie eine Autorisierung stornieren müssen, können Sie den [PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) stornieren.

## Optional: Ereignisse nach Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

- **Manuelles Bearbeiten von Ereignissen im Dashboard**

  Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen.

- **Erstellen eines benutzerdefinierten Webhooks**

  Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der Stripe CLI.

- **Integrieren einer vorgefertigten App**

  Bearbeiten Sie häufige Unternehmensereignisse, wie z.&nbsp;B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.

## Optional: Afterpay-Integration testen

Testen Sie Ihre Afterpay-Integration mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`.

Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`.

Für die [manuelle Erfassung](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) von PaymentIntents im Testmodus läuft der nicht erfasste PaymentIntent 10 Minuten nach erfolgreicher Autorisierung automatisch ab.

## Fehlgeschlagene Zahlungen

Afterpay berücksichtigt mehrere Faktoren bei der Entscheidung, ob eine Transaktion akzeptiert oder abgelehnt wird (zum Beispiel die Dauer der Nutzung von Afterpay durch den/die Käufer/in, den ausstehenden Betrag, den der/die Kund/in zurückzahlen muss, oder den Wert der aktuellen Bestellung).

Sie sollten in Ihrem Bezahlvorgang immer weitere Zahlungsoptionen wie `card` anbieten, da Afterpay-Zahlungen eine höhere Ablehnungsrate haben als viele andere Zahlungsmethoden. In diesen Fällen wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Bei einem Afterpay-[PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) mit dem Status `requires_action` müssen Kundinnen/Kunden die Zahlung innerhalb von 3&nbsp;Stunden nach Weiterleitung zur Afterpay-Website abschließen. Wenn nach 3&nbsp;Stunden keine Aktion erfolgt ist, wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt, und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Teilen Sie Ihren Kund/innen in diesen Fällen mit, dass sie es mit einer anderen Zahlungsoption versuchen sollten, die in Ihrem Bezahlvorgang zur Verfügung gestellt wird.

## Fehlercodes

Im Folgenden finden Sie die häufigsten Fehlercodes und die entsprechenden empfohlenen Maßnahmen:

| Fehlercode                               | Empfohlene Maßnahme                                                                                                                                                                                                                                                                          |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Ein allgemeiner Fehler, der darauf hinweist, dass der Afterpay-Bezahlvorgang fehlgeschlagen ist. Es kann sich auch um eine abgelehnte Zahlung handeln, die nicht als Fehlercode für abgelehnte Zahlungen angezeigt wird.                                                                     |
| `payment_method_provider_decline`        | Afterpay hat die Kundenzahlung abgelehnt. Als nächsten Schritt muss sich der Kunde/die Kundin an Afterpay wenden, um weitere Informationen einzuholen.                                                                                                                                       |
| `payment_intent_payment_attempt_expired` | Die Kundin/der Kunde hat die Zahlung auf der Afterpay-Checkout-Seite nicht abgeschlossen und die Payment-Sitzung ist abgelaufen. Stripe setzt PaymentIntents, die nicht erfolgreich autorisiert wurden, automatisch 3&nbsp;Stunden nach Erstellung des ursprünglichen Checkouts außer Kraft. |
| `payment_method_not_available`           | Bei Afterpay ist ein Servicefehler aufgetreten und die Anfrage kann nicht abgeschlossen werden. Versuchen Sie es zu einem späteren Zeitpunkt erneut.                                                                                                                                         |
| `amount_too_small`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |
| `amount_too_large`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |


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

> Der Inhalt dieses Abschnitts bezieht sich auf ein *Legacy* (Technology that's no longer recommended)-Produkt. Verwenden Sie den Leitfaden [Zahlungen akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md) für den aktuellsten Integrationspfad. Auch wenn Stripe dieses Produkt jetzt noch unterstützt, kann sich dies ändern, wenn das Produkt nicht mehr unterstützt wird.

Stripe-Nutzer/innen können die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md)&nbsp;– einen zentralen Integrationspfad für die Erstellung von Zahlungen mit einer beliebigen unterstützten Methode&nbsp;– verwenden, um Zahlungen per [Afterpay](https://www.afterpay.com/) von Kundinnen und Kunden aus folgenden Ländern anzunehmen:

- Australien
- Kanada
- Neuseeland
- Vereinigtes Königreich
- Vereinigte Staaten

Afterpay ist eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage) mit [sofortiger Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification), bei der Kundinnen/Kunden ihre Zahlung [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Kundinnen/Kunden werden auf die Afterpay-Website weitergeleitet, wo sie den Bedingungen eines Ratenzahlungsvertrags zustimmen. Wenn die Kundinnen/Kunden die Bedingungen akzeptieren, werden die Gelder garantiert und auf Ihr Stripe-Konto überwiesen. Die Kundinnen/Kunden zahlen die Zahlung über eine gewissen Zeitraum direkt an Afterpay zurück.

> Bevor Sie mit der Integration beginnen, vergewissern Sie sich, dass Ihr Konto für Afterpay geeignet ist. Dies können Sie in Ihren [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) prüfen.

## Stripe einrichten [Serverseitig] [Clientseitig]

### Serverseitig

Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Clientseitig

Das [React Native SDK](https://github.com/stripe/stripe-react-native) ist Open Source und vollständig dokumentiert. Intern werden [native iOS](https://github.com/stripe/stripe-ios) und [Android](https://github.com/stripe/stripe-android) SDKs verwendet. Um das React Native SDK von Stripe zu installieren, führen Sie einen der folgenden Befehle im Verzeichnis Ihres Projekts aus (je nachdem, welchen Paket-Manager Sie verwenden):

#### yarn

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

#### npm

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

Installieren Sie als Nächstes einige weitere erforderliche Abhängigkeiten:

- Für iOS wechseln Sie in das Verzeichnis **ios** und führen Sie `pod install` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Dependencies installiert haben.
- Für Android müssen keine Abhängigkeiten mehr installiert werden.

> Wir empfehlen Ihnen, die [offizielle Anleitung zu TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) zu befolgen, um TypeScript zu unterstützen.

### Stripe Initialisierung

Um Stripe in Ihrer React Native-App zu initialisieren, umschließen Sie entweder Ihren Zahlungsbildschirm mit der Komponente `StripeProvider` oder verwenden Sie die Initialisierungsmethode `initStripe`. Nur der [veröffentlichbare API-Schlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) in `publishableKey` ist erforderlich. Das folgende Beispiel zeigt, wie Stripe mithilfe der Komponente `StripeProvider` initialisiert wird.

```jsx
import { useState, useEffect } from 'react';
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  const [publishableKey, setPublishableKey] = useState('');

  const fetchPublishableKey = async () => {
    const key = await fetchKey(); // fetch key from your server here
    setPublishableKey(key);
  };

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

  return (
    <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>
  );
}
```

> Verwenden Sie Ihre API-[Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App.

## PaymentIntent erstellen [Serverseitig] [Clientseitig]

Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht, eine Kundenzahlung einzuziehen, darstellt und den gesamten Zahlungsvorgang dokumentiert.

### Serverseitig

Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag sowie eine unterstützte Währung an. Wenn Sie bereits eine Integration mit dem [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) haben, fügen Sie `afterpay_clearpay` zur Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren `PaymentIntent` hinzu.

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

### Clientseitig

Im zurückgegebenen PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, mit dem der Client den Zahlungsvorgang sicher abschließen kann, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie das zugehörige Client-Geheimnis.

```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};
};
```

## Angaben zur Zahlungsmethode erfassen [Clientseitig]

Für Afterpay sind die Abrechnungsdaten erforderlich, damit die Zahlung durchgeführt werden kann. Erfassen Sie in Ihrer App die erforderlichen Abrechnungsdaten von den Kundinnen/Kunden:

- Vollständiger Name (Vor- und Nachname)
- E-Mail-Adresse
- Vollständige Rechnungsadresse

Auch wenn keine Versanddaten erforderlich sind, können Sie die Authentifizierungsraten verbessern. Um Versanddaten zu erfassen, erfassen Sie folgende Daten von der Kundin/dem Kunden:

- Vollständiger Name
- Vollständige Versandadresse

```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>
  );
}
```

## Zahlung an Stripe senden [Clientseitig]

Rufen Sie das Client-Geheimnis aus dem von Ihnen erstellten PaymentIntent ab und rufen Sie `confirmPayment` auf. Achten Sie auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Zahlung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden.

```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: Umgang mit Deep Linking

Wenn Kundinnen/Kunden Ihre App verlassen (zum Beispiel um sich in Safari oder ihrer Banking-App zu authentifizieren), bieten Sie ihnen eine Möglichkeit, automatisch zu Ihrer App zurückzukehren. Für viele Arten von Zahlungsmethoden *ist* eine Rückgabe-URL erforderlich. Wenn Sie keine angeben, können wir Ihren Nutzer/innen keine Zahlungsmethoden anbieten, für die eine Rückgabe-URL erforderlich ist, selbst wenn Sie diese aktiviert haben.

So geben Sie eine Rückgabe-URL an:

1. [Registrieren](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) Sie eine benutzerdefinierte URL. Universelle Links werden nicht unterstützt.
1. [Konfigurieren](https://reactnative.dev/docs/linking) Sie Ihre benutzerdefinierte URL.
1. Richten Sie Ihre Root-Komponente so ein, dass sie die URL an das Stripe SDK weitergibt, wie unten gezeigt.

> Wenn Sie Expo verwenden, [stellen Sie Ihr Schema](https://docs.expo.io/guides/linking/#in-a-standalone-app) in der Datei `app.json` ein.

```jsx
import { useEffect, useCallback } from 'react';
import { Linking } from 'react-native';
import { useStripe } from '@stripe/stripe-react-native';

export default function MyApp() {
  const { handleURLCallback } = useStripe();

  const handleDeepLink = useCallback(
    async (url: string | null) => {
      if (url) {
        const stripeHandled = await handleURLCallback(url);
        if (stripeHandled) {
          // This was a Stripe URL - you can return or add extra handling here as you see fit
        } else {
          // This was NOT a Stripe URL – handle as you normally would
        }
      }
    },
    [handleURLCallback]
  );

  useEffect(() => {
    const getUrlAsync = async () => {
      const initialUrl = await Linking.getInitialURL();
      handleDeepLink(initialUrl);
    };

    getUrlAsync();

    const deepLinkListener = Linking.addEventListener(
      'url',
      (event: { url: string }) => {
        handleDeepLink(event.url);
      }
    );

    return () => deepLinkListener.remove();
  }, [handleDeepLink]);

  return (
    <View>
      <AwesomeAppComponent />
    </View>
  );
}
```

Weitere Informationen zu nativen URL-Schemen finden Sie in der Dokumentation für [Android](https://developer.android.com/training/app-links/deep-linking) und [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app).

## Optional: Posten zum PaymentIntent hinzufügen

Sie haben die Möglichkeit, Einzelpostendaten zu akzeptieren, um Afterpay weitere Risikosignale zu liefern. Diese Funktion befindet sich derzeit in der privaten Beta-Phase. Bitte kontaktieren Sie uns über das Formular im [Stripe-Support](https://support.stripe.com), wenn Sie Zugang beantragen möchten.

## Optional: Separate Autorisierung und Erfassung

Anders als bei der [getrennten Autorisierung und Erfassung für Kartenzahlungen](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) belastet Afterpay die Kundin/den Kunden mit der ersten Rate der Zahlung zum Zeitpunkt der Autorisierung. Sie haben dann nach der Autorisierung maximal 13&nbsp;Tage Zeit, den Rest der Zahlung zu erfassen. Wenn Sie die Zahlung in diesem Zeitfenster nicht erfassen, erhält der Kunde/die Kundin eine Rückerstattung für diese Rate und ihm/ihr werden keine weiteren Raten berechnet. Der Kundin/Dem Kunden werden dann keine weiteren Raten mehr in Rechnung gestellt. In diesen Fällen storniert Stripe außerdem den PaymentIntent und übermittelt das Ereignis [payment_intent.canceled](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.canceled).

Wenn Sie wissen, dass Sie die Zahlung nicht erfassen können, sollten Sie [den PaymentIntent stornieren](https://docs.stripe.com/refunds.md#cancel-payment) und nicht warten, bis das Zeitfenster von 13&nbsp;Tagen abgelaufen ist. Durch die proaktive Stornierung des PaymentIntent wird die erste Rate sofort an die Kundin/den Kunden zurückerstattet, sodass keine Verwirrung hinsichtlich der Zahlungen in ihrer Abrechnung entsteht.

### Stripe anweisen, nur die Autorisierung durchzuführen

Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag auf dem Afterpay-Konto der Kundin/des Kunden zu autorisieren.

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

Bei erfolgreicher Autorisierung übermittelt Stripe das Ereignis [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Lesen Sie in unserem [Leitfaden zu Ereignissen](https://docs.stripe.com/api/events.md) mehr dazu.

### Die Gelder erfassen

Nach erfolgreicher Autorisierung wechselt der [Status](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) des PaymentIntent zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine PaymentIntent-[Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) durch. Standardmäßig wird der gesamte autorisierte Betrag erfasst. Sie können keinen höheren, aber einen niedrigeren Betrag erfassen.

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

### (Optional) Autorisierung stornieren

Wenn Sie eine Autorisierung stornieren müssen, können Sie den [PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) stornieren.

## Optional: Ereignisse nach Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

- **Manuelles Bearbeiten von Ereignissen im Dashboard**

  Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen.

- **Erstellen eines benutzerdefinierten Webhooks**

  Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der Stripe CLI.

- **Integrieren einer vorgefertigten App**

  Bearbeiten Sie häufige Unternehmensereignisse, wie z.&nbsp;B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.

## Optional: Afterpay-Integration testen

Testen Sie Ihre Afterpay-Integration mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`.

Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`.

Für die [manuelle Erfassung](https://docs.stripe.com/payments/afterpay-clearpay/accept-a-payment.md#manual-capture) von PaymentIntents im Testmodus läuft der nicht erfasste PaymentIntent 10 Minuten nach erfolgreicher Autorisierung automatisch ab.

## Fehlgeschlagene Zahlungen

Afterpay berücksichtigt mehrere Faktoren bei der Entscheidung, ob eine Transaktion akzeptiert oder abgelehnt wird (zum Beispiel die Dauer der Nutzung von Afterpay durch den/die Käufer/in, den ausstehenden Betrag, den der/die Kund/in zurückzahlen muss, oder den Wert der aktuellen Bestellung).

Sie sollten in Ihrem Bezahlvorgang immer weitere Zahlungsoptionen wie `card` anbieten, da Afterpay-Zahlungen eine höhere Ablehnungsrate haben als viele andere Zahlungsmethoden. In diesen Fällen wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Bei einem Afterpay-[PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) mit dem Status `requires_action` müssen Kundinnen/Kunden die Zahlung innerhalb von 3&nbsp;Stunden nach Weiterleitung zur Afterpay-Website abschließen. Wenn nach 3&nbsp;Stunden keine Aktion erfolgt ist, wird die [PaymentMethod](https://docs.stripe.com/api/payment_methods/object.md) getrennt, und der Status des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekts wechselt automatisch zu `requires_payment_method`.

Teilen Sie Ihren Kund/innen in diesen Fällen mit, dass sie es mit einer anderen Zahlungsoption versuchen sollten, die in Ihrem Bezahlvorgang zur Verfügung gestellt wird.

## Fehlercodes

Im Folgenden finden Sie die häufigsten Fehlercodes und die entsprechenden empfohlenen Maßnahmen:

| Fehlercode                               | Empfohlene Maßnahme                                                                                                                                                                                                                                                                          |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_payment_attempt_failed`  | Ein allgemeiner Fehler, der darauf hinweist, dass der Afterpay-Bezahlvorgang fehlgeschlagen ist. Es kann sich auch um eine abgelehnte Zahlung handeln, die nicht als Fehlercode für abgelehnte Zahlungen angezeigt wird.                                                                     |
| `payment_method_provider_decline`        | Afterpay hat die Kundenzahlung abgelehnt. Als nächsten Schritt muss sich der Kunde/die Kundin an Afterpay wenden, um weitere Informationen einzuholen.                                                                                                                                       |
| `payment_intent_payment_attempt_expired` | Die Kundin/der Kunde hat die Zahlung auf der Afterpay-Checkout-Seite nicht abgeschlossen und die Payment-Sitzung ist abgelaufen. Stripe setzt PaymentIntents, die nicht erfolgreich autorisiert wurden, automatisch 3&nbsp;Stunden nach Erstellung des ursprünglichen Checkouts außer Kraft. |
| `payment_method_not_available`           | Bei Afterpay ist ein Servicefehler aufgetreten und die Anfrage kann nicht abgeschlossen werden. Versuchen Sie es zu einem späteren Zeitpunkt erneut.                                                                                                                                         |
| `amount_too_small`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |
| `amount_too_large`                       | Geben Sie einen Betrag ein, der innerhalb der [Standard-Transaktionslimits](https://docs.stripe.com/payments/afterpay-clearpay.md#collection-schedule) von Afterpay für das jeweilige Land liegt.                                                                                            |