# Zahlungen mit Amazon Pay annehmen

So richten Sie Ihre Integration mit Amazon Pay ein.

# Direct API


Bei Amazon Pay handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden ihre Zahlungen [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei Zahlungen mit Amazon Pay werden Kundinnen/Kunden zur Autorisierung der Zahlung von Ihrer Website oder App weitergeleitet und anschließend zurückgeleitet. Sie erhalten dann eine [sofortige Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) über den Erfolg oder das Fehlschlagen der Zahlung.

## Stripe einrichten [Serverseitig]

[Erstellen Sie ein Stripe-Konto](https://dashboard.stripe.com/register), falls Sie noch keines haben.

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 darstellt, eine Zahlung von Ihrem Kunden/Ihrer Kundin einzuziehen. Es verfolgt den Lebenszyklus des Zahlungsvorgangs. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und eine [unterstützte Währung](https://docs.stripe.com/payments/amazon-pay.md#supported-currencies) an. Wenn Sie über eine bestehende [Payment Intents](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `amazon_pay` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu.

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

Der `PaymentIntent` enthält ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Senden Sie das Client-Geheimnis an Ihren Client, um Zahlungen sicher abzuschließen, anstatt das gesamte `PaymentIntent`-Objekt zu übergeben.

### 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 %>">
  <button id="submit">Submit</button>
</form>
```

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

## Zu Amazon Pay weiterleiten [Clientseitig]

Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit Amazon Pay bezahlen, verwenden Sie Stripe.js, um die Zahlungen an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist die grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie verarbeitet automatisch komplexe Szenarien wie die nachfolgend beschriebene Weiterleitung und ermöglicht die Erweiterung Ihrer Integration durch zusätzliche Zahlungsmethoden. Binden Sie das Stripe.js-Skript in Ihre Bezahlseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen.

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

Erstellen Sie auf Ihrer Checkout-Seite mit dem folgenden JavaScript eine Instanz von Stripe.js.

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

Verwenden Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent` und rufen Sie `stripe.confirmPayment` auf, um die Amazon Pay-Weiterleitung zu handhaben. Fügen Sie eine `return_url` hinzu, um festzulegen, wohin Stripe die Kundinnen/Kunden nach Zahlungsabschluss weiterleitet.

```javascript
const form = document.getElementById('payment-form');

form.addEventListener('submit', async function(event) {
  event.preventDefault();

  // Set the clientSecret of the PaymentIntent
  const { error } = await stripe.confirmPayment({
    clientSecret: clientSecret,
    confirmParams: {
      payment_method_data: {
        type: 'amazon_pay',
      },
      // Return URL where the customer should be redirected after the authorization
      return_url: `${window.location.href}`,
    },
  });

  if (error) {
    // Inform the customer that there was an error.
    const errorElement = document.getElementById('error-message');
    errorElement.textContent = result.error.message;
  }
});
```

Die `return_url` verweist auf eine Seite auf Ihrer Website, auf der das Ergebnis der Zahlung angezeigt wird. Durch [Verifizieren des Status](https://docs.stripe.com/payments/payment-intents/verifying-status.md#checking-status) des `PaymentIntent` können Sie festlegen, was angezeigt werden soll. Zur Verifizierung des Status enthält die Stripe-Weiterleitung zu der `return_url` die folgenden URL-Abfrageparameter. Sie können auch Ihre eigenen Abfrageparameter an die `return_url` anhängen. Diese bleiben während des gesamten Weiterleitungsprozesses bestehen.

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

## Optional: Ereignisse nach der 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).

### Ereignisse empfangen und Geschäftsaktionen ausführen

Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen.

#### Manuell

Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen.

- [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments)

#### Benutzerdefinierter Code

Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben.

- [Erstellen eines benutzerdefinierten Webhooks](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Vorgefertigte Apps

Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung.

## Unterstützte Währungen

Sie können Amazon Pay-Zahlungen in jeder der unterstützten Währungen erstellen, unabhängig davon, in welchem Land Ihr Unternehmen tätig ist, mit Ausnahme der USA.

| Land                                                                                                                                                                                              | Währung                                                                            |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Österreich, Belgien, Zypern, Dänemark, Frankreich, Deutschland, Ungarn, Irland, Italien, Luxemburg, Niederlande, Portugal, Spanien, Schweden, Schweiz, Vereinigtes Königreich, Vereinigte Staaten | `aud`, `gbp`, `dkk`, `eur`, `hkd`, `jpy`, `nzd`, `nok`, `zar`, `sek`, `chf`, `usd` |