# PayTo-Zahlungen

So akzeptieren Sie Zahlungen per PayTo.

PayTo ist eine Echtzeit-Zahlungsmethode in Australien für die Annahme von einmaligen und wiederkehrenden Zahlungen. Bei der Zahlung mit PayTo [authentifizieren und genehmigen](https://docs.stripe.com/payments/payment-methods.md#customer-actions) Kundinnen und Kunden Mandate über ihre mobile Banking-App oder ihr Online-Banking.

Sie erhalten eine [verzögerte Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) darüber, ob die Zahlung erfolgreich war oder nicht. Stripe sendet normalerweise innerhalb von 60 Sekunden nach der Autorisierung des Mandats eine Benachrichtigung über den endgültigen Status der Zahlung.

# Checkout

> This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/payto/accept-a-payment?payment-ui=checkout.

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

## Kompatibilität bestimmen

**Kundenregion**: Australia

**Unterstützte Währungen**: `aud`

**Transaktionswährungen**: `aud`

**Zahlungsmodus**: Yes

**Einrichtungsmodus**: Yes

**Abonnementmodus**: Yes

Um PayTo-Zahlungen in Checkout zu unterstützen, drücken Sie alle *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) für alle Posten in AUD aus (Währungscode `aud`).

## Eine Zahlung akzeptieren

> Diese Anleitung baut auf der grundlegenden Checkout-Integration zum [Akzeptieren von Zahlungen](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted) auf.

Um Payto als Zahlungsmethode zu aktivieren, erstellen Sie eine neue [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md):

1. Fügen Sie `payto` zur Liste der `payment_method_types` hinzu.
1. Stellen Sie sicher, dass alle Ihre `line_items` die Währung `aud` verwenden.

#### Von Stripe gehostete Seite

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -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]=payto" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Eingebettetes Formular

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -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]=payto" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

### Abwicklung Ihrer Bestellungen

Informieren Sie sich über die [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md), nachdem Sie eine Zahlung angenommen haben.

## Ihre Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `{any_prefix}+decline@{any_domain}`                      | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `000000`   | `333333335` | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `000000`   | `333333337` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |


# Elements

> This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/payto/accept-a-payment?payment-ui=elements.

## Stripe einrichten [Serverseitig]

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

Um von Ihrer Anwendung auf die Stripe API zuzugreifen, verwenden Sie unsere offiziellen Bibliotheken:

#### 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 Kundenzahlung einzuziehen, und den Zahlungsvorgang dokumentiert. Um einen `PaymentIntent` zu erstellen, der eine ShopeePay-Zahlungsmethode akzeptiert, geben Sie den einzuziehenden Betrag, `aud` als Währung und `payto` in der Liste der [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) an. Wenn Sie eine Liste mit Zahlungsmethodentypen haben, die Sie beim Erstellen eines `PaymentIntent` übergeben, fügen Sie dieser Liste `payto` hinzu.

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

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

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

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

### 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 Bezahlseite 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 Ihrer Bezahlseite hinzufügen

Das Payment Element benötigt einen festen Platz auf Ihrer Zahlungsseite. 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>
```

Wenn das vorherige Formular geladen wurde, erstellen Sie eine Instanz des Payment Element und verbinden es mit dem DOM-Knoten (Container). Übergeben Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus dem vorherigen Schritt an `options`, wenn Sie die [Elements](https://docs.stripe.com/js/elements_object/create)-Instanz erstellen:

Gehen Sie sorgfältig mit dem Client-Geheimnis um, denn es kann die Zahlung abschließen. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und geben Sie es nur dem/der Kund/in preis.

```javascript
const options = {
  clientSecret: '{{CLIENT_SECRET}}',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout form, passing the client secret obtained in a previous stepconst elements = stripe.elements(options);
// Optional: Autofill user's saved payment methods. If the customer's
// email is known when the page is loaded, you can pass the email
// to the linkAuthenticationElement on mount:
//
//   linkAuthenticationElement.mount("#link-authentication-element",  {
//     defaultValues: {
//       email: 'jenny.rosen@example.com',
//     }
//   })

// 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 Zahlungsseite 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. Übergeben Sie auch das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus dem vorherigen Schritt als `options` an den `Elements`-Anbieter.

```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 = {
    // passing the client secret obtained in step 3
    clientSecret: '{{CLIENT_SECRET}}',
    // 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>
      // Optional: Autofill user's saved payment methods. If the customer's
      // email is known when the page is loaded, you can pass the email
      // to the linkAuthenticationElement
      //
      // <LinkAuthenticationElement id="link-authentication-element"
        // Prefill the email field like so:
        // options={{defaultValues: {email: 'foo@bar.com'}}}
      // /><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

## 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. Dadurch wird eine Autorisierungsanfrage an die Käufer/innen gesendet.

> Die Ausführung von `stripe.confirmPayment` kann einige Sekunden dauern, während Sie auf die Autorisierung der Zahlung auf Kundenseite warten. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Absendung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus.

#### HTML + JS

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

form.addEventListener('submit', async (event) => {
  event.preventDefault();
const {error, paymentIntent} = await stripe.confirmPayment({
    //`Elements` instance that was used to create the Payment Element
    elements,
    redirect: 'if_required',
  });

  const message = document.querySelector('#message')
  if (error) {
    // This point will only be reached if there is an immediate error when
    // confirming the payment. Show error to your customer (for example, payment
    // details incomplete)
    message.innerText = error.message;
  } else {
    // This will execute if the confirm request is successful, or if the
    // payment fails asynchronously.
    switch (paymentIntent.status) {
      case 'succeeded':
        message.innerText = 'Success! Payment received.';
        break;

      case 'processing':
        message.innerText = "Payment processing. We'll update you when payment is received.";
        break;

      case 'requires_payment_method':
        message.innerText = 'Payment failed. Please try another payment method.';
        // Redirect your user back to your payment page to attempt collecting
        // payment again
        break;

      default:
        message.innerText = 'Something went wrong.';
        break;
    }
  }
});
```

#### React

Verwenden Sie die Hooks [useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook) und [useElements](https://docs.stripe.com/sdks/stripejs-react.md#useelements-hook), um [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) über die Komponente Ihres Zahlungsformulars aufzurufen.

Wenn Sie herkömmliche Klassenkomponenten gegenüber Hooks bevorzugen, können Sie stattdessen einen [ElementsConsumer](https://docs.stripe.com/sdks/stripejs-react.md#elements-consumer) nutzen.

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

const CheckoutForm = () => {
  const stripe = useStripe();
  const elements = useElements();

  const [message, setMessage] = useState(null);

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

    if (!stripe || !elements) {
      // Stripe.js hasn't yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }
const {error, paymentIntent} = await stripe.confirmPayment({
      //`Elements` instance that was used to create the Payment Element
      elements,
      redirect: 'if_required',
    });


    if (error) {
      // This point will only be reached if there is an immediate error when
      // confirming the payment. Show error to your customer (for example, payment
      // details incomplete)
      setMessage(error.message);
    } else {
      // This will execute if the confirm request is successful, or if the
      // payment fails asynchronously.
      switch (paymentIntent.status) {
        case 'succeeded':
          setMessage('Success! Payment received.');
          break;

        case 'processing':
          setMessage("Payment processing. We'll update you when payment is received.");
          break;

        case 'requires_payment_method':
          setMessage('Payment failed. Please try another payment method.');
          // Redirect your user back to your payment page to attempt collecting
          // payment again
          break;

        default:
          setMessage('Something went wrong.');
          break;
      }
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button disabled={!stripe}>Submit</button>
      {/* Show message to your customers */}
      {message && <div>{message}</div>}
    </form>
  )
};

export default CheckoutForm;
```

## Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `{any_prefix}+decline@{any_domain}`                      | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `000000`   | `333333335` | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `000000`   | `333333337` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |

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

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

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the 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.


# Direct API

> This is a Direct API for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/payto/accept-a-payment?payment-ui=direct-api.

## Stripe einrichten [Serverseitig]

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

Um von Ihrer Anwendung auf die Stripe API zuzugreifen, verwenden Sie unsere offiziellen Bibliotheken:

#### 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 Kundenzahlung einzuziehen, und den Zahlungsvorgang dokumentiert. Um einen `PaymentIntent` zu erstellen, der eine ShopeePay-Zahlungsmethode akzeptiert, geben Sie den einzuziehenden Betrag, `aud` als Währung und `payto` in der Liste der [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) an. Wenn Sie eine Liste mit Zahlungsmethodentypen haben, die Sie beim Erstellen eines `PaymentIntent` übergeben, fügen Sie dieser Liste `payto` hinzu.

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

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

## Angaben zur Zahlungsmethode erfassen und die Zahlung übermitteln [Clientseitig]

Wenn Sie die Zahlung bestätigen, übergeben Sie das Client-Geheimnis.

> Gehen Sie sorgfältig mit dem Client-Geheimnis um, da es den Zugriff auf den PaymentIntent ermöglicht. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden.

Verwenden Sie `stripe.confirmPayToPayment`, um die Zahlungsautorisierung mit Ihrer Kundin/Ihrem Kunden zu initiieren.

Die Kundin/der Kunde erhält eine Benachrichtigung über die Zahlungsanfrage und genehmigt oder lehnt diese über die Banking-App ab.

```javascript
// Inititates the payment request notification to the customer
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      billing_details: {
        // Name is required for all PayTo payments
        name: 'Jenny Rosen',
        // Email is required only for PayID payments, for refund processing
        email: 'jenny@example.com'
      },
      payto: {
        // Either provide a PayID (typically an email or phone number)
        pay_id: 'jenny@example.com'
        // ...or provide bank account details
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  }
});
```

Standardmäßig fragt Stripe.js nach Aktualisierungen des PaymentIntent. Das von `confirmPayToPayment` zurückgegebene Promise wird aufgelöst, wenn die PaymentIntent den Status `succeeded` erreicht, oder wenn die Zahlung fehlschlägt und die PaymentIntent wieder in den Status `requires_payment_method` wechselt. Nähere Informationen dazu, wie diese Übergänge stattfinden, finden Sie im [Ablauf eines PaymentIntent](https://docs.stripe.com/payments/paymentintents/lifecycle.md).

Deaktivieren Sie die automatische Abfrage, indem Sie `handleActions: false` festlegen, um sich selbst abzufragen:

```javascript
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      payto: {
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
  { handleActions: false } // <---- Like this
)
```

Rufen Sie in diesem Fall die [PaymentIntents API](https://docs.stripe.com/api/payment_intents/retrieve.md) auf, um den Status der PaymentIntent selbst abzurufen.

## Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `{any_prefix}+decline@{any_domain}`                      | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` auf `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`.                                                                                                                               |
| `000000`   | `333333335` | Der PaymentIntent-Status wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück.                                                         |
| `000000`   | `333333337` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_timeout` und den Ablehnungscode `generic_decline` zurück.                                                                    |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                              |

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

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

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the 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.