Weiter zum Inhalt
Konto erstellen
 oder
anmelden
Das Logo der Stripe-Dokumentation
/
Konto erstellen
Anmelden

Mit den in Connect eingebetteten Komponenten loslegen

Erfahren Sie, wie Sie Dashboard-Funktionen in Ihre Website einbetten.

Verwenden Sie die in Connect eingebetteten Komponenten, um Dashboard-Funktionen für verbundene Konten zu Ihrer Website hinzuzufügen. Mit diesen Bibliotheken und der unterstützenden API können Sie Ihren Nutzer/innen direkt in Ihrem Dashboard Zugriff auf Stripe Produkte gewähren.

Eine umfassende Version dieses Handbuchs finden Sie im Schnellstart zur Integration eingebetteter Connect-Komponenten. Dort können Sie auch eine Beispielintegration herunterladen. Um das Erscheinungsbild der in Connect eingebetteten Komponenten anzupassen, verwenden Sie die Option appearance bei der Initialisierung von StripeConnectInstance. Siehe die vollständige Liste der Darstellungsparameter.

Connect.js initialisieren
Clientseitig
Serverseitig

Stripe verwendet eine AccountSession, um Ihre Absicht zum Ausdruck zu bringen, den API -Zugriff auf Ihr verbundenes Konto zu delegieren.

Die AccountSessions API gibt ein Client-Geheimnis zurück, das es einer eingebetteten Komponente im Web-Client ermöglicht, so auf die Ressourcen eines verbundenen Kontos zuzugreifen, als ob Sie die API -Aufrufe für sie durchführen würden.

AccountSession erstellen Server

In einer einseitigen Anwendung initiiert Ihr Client eine Anfrage an Ihren Server, um die Kontositzung zu erhalten. Sie können einen neuen Endpoint auf Ihrem Server erstellen, der das Client-Geheimnis an den Browser zurückgibt:

main.rb
require 'sinatra'
require 'stripe'
# This is a placeholder - it should be replaced with your secret API key.
# Sign in to see your own test API key embedded in code samples.
# Don’t submit any personally identifiable information in requests made with this key.
Stripe.api_key = 
'sk_test_4eC39HqLyjWDarjtT1zdp7dc'


post '/account_session' do
  content_type 'application/json'

  # Create an AccountSession
  begin
    account_session = Stripe::AccountSession.create({
      account: 
'{{CONNECTED_ACCOUNT_ID}}'
,
      components: {
        payments: {
          enabled: true,
          features: {
            refund_management: true,
            dispute_management: true,
            capture_payments: true
          }
        }
      }
    })

    {
      client_secret: account_session[:client_secret]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account session: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end

Create Account Session API

The Create Account Session API determines component and feature access for Connect embedded components. Stripe enforces these parameters for any components that correspond to the account session. If your site supports multiple user roles, make sure components and features that are enabled for that account session correspond to the current user’s role. For example, you can enable refund management only for administrators of your site, but not for other users. To ensure user role access are enforced, your backend must host the logic that maps your site’s user role to account session components.

Connect.js einrichten Client

Installieren Sie das npm-Paket, um Connect.js als Modul zu verwenden.

Command Line
npm install --save @stripe/connect-js

Connect.js laden und initialisieren Client

Rufen Sie loadConnectAndInitialize mit Ihrem veröffentlichbaren Schlüssel und einer Funktionalität auf, die ein Client-Geheimnis durch Aufrufen des neuen Endpoints abruft, den Sie auf Ihrem Server erstellt haben. Verwenden Sie die zurückgegebene StripeConnectInstance, um eingebettete Komponenten zu erstellen. Nachdem Sie Connect.js initialisiert haben, können Sie jederzeit Komponenten im DOM bereitstellen oder ihre Bereitstellung aufheben. Dies umfasst alle Elemente, die in React- oder Vue-Portalen gerendert werden.

Um eine component zu erstellen, rufen Sie create in der oben erstellen StripeConnectInstance auf, und übergeben Sie dann den Komponentennamen. Dadurch wird ein nutzerdefiniertes Element zurückgegeben, das Connect.js registriert und verwendet, um Ihr DOM automatisch mit Stripe zu verbinden. Sie können dieses Element dann an Ihr DOM append.

Rufen Sie create mit payments auf und fügen Sie das Ergebnis dann Ihrem DOM hinzu, um eine Nutzeroberfläche für Zahlungen zu rendern.

index.html
<head>
  <script type="module" src="index.js" defer></script>
</head>
<body>
  <h1>Payments</h1>
  <div id="container"></div>
  <div id="error" hidden>Something went wrong!</div>
</body>
index.js
import {loadConnectAndInitialize} from '@stripe/connect-js';

const fetchClientSecret = async () => {
  // Fetch the AccountSession client secret
  const response = await fetch('/account_session', { method: "POST" });
  if (!response.ok) {
    // Handle errors on the client side here
    const {error} = await response.json();
    console.error('An error occurred: ', error);
    document.querySelector('#error').removeAttribute('hidden');
    return undefined;
  } else {
    const {client_secret: clientSecret} = await response.json();
    document.querySelector('#error').setAttribute('hidden', '');
    return clientSecret;
  }
}

const stripeConnectInstance = loadConnectAndInitialize({
    // This is a placeholder - it should be replaced with your publishable API key.
    // Sign in to see your own test API key embedded in code samples.
    // Don’t submit any personally identifiable information in requests made with this key.
    publishableKey: 
"pk_test_TYooMQauvdEDq54NiTphI7jx"
,
    fetchClientSecret: fetchClientSecret,
  });
const paymentComponent = stripeConnectInstance.create("payments");
const container = document.getElementById("container");
container.appendChild(paymentComponent);

Eine vollständige Liste der unterstützten eingebetteten Komponenten anzeigen →

Connect.js konfigurieren
Clientseitig

Die Methode loadConnectAndInitialize auf dem Client benötigt mehrere Optionen, um Connect.js zu konfigurieren.

OptionBeschreibung
publishableKeyDer veröffentlichbare Schlüssel für Ihre Integration.erforderlich
fetchClientSecretDie Funktion, die das von /v1/account_sessions zurückgegebene Client-Geheimnis abruft. Dadurch wird StripeConnectInstance mitgeteilt, an welches Konto der Zugriff delegiert werden soll. Diese Funktion wird auch verwendet, um eine geheime Client-Funktion abzurufen, um die Sitzung zu aktualisieren, wenn sie abläuft.erforderlich
appearanceEin Objekt zum Anpassen des Erscheinungsbilds der in Connect eingebetteten Komponenten.optional
localeEin Parameter zum Angeben des Gebietsschemas, das eingebettete Connect-Komponenten nutzen. Das Gebietsschema ist standardmäßig auf die Browser-Sprache eingestellt. Wenn das angegebene Gebietsschema nicht direkt unterstützt wird, wird eine passende Alternative verwendet (so würde fr-be z. B. wahrscheinlich auf fr-fr zurückgreifen). Siehe Lokalisierung, um die Liste der unterstützten Gebietsschemen anzuzeigen.optional
fontsEin Array mit benutzerdefinierten Schriftarten, die von allen eingebetteten Komponenten verwendet werden können, die aus einer StripeConnectInstance erstellt werden. Schriftarten können als CssFontSource oder CustomFontSource angegeben werden.optional

Erscheinungsbild der in Connect eingebetteten Komponenten anpassen

Wir bieten eine Reihe von Optionen an, um das Erscheinungsbild von in Connect eingebetteten Komponenten anzupassen. Diese Anpassungen betreffen Schaltflächen, Symbole und andere Akzentuierungen in unserem Designsystem.

Sie können diese Optionen bei der Initialisierung von StripeConnectInstance festlegen, indem Sie Werte an das appearance-Objekt übergeben. Sie können diese Connect.js-Optionen nur zum Ändern der Formate in den in Connect eingebetteten Komponenten verwenden. Die Schriftfamilie und die Hintergrundfarbe eingebetteter Connect-Komponenten können mit CSS-Selektoren überschrieben werden. Stripe unterstützt das Überschreiben anderer Stile jedoch nicht.

index.js
const fetchClientSecret = async () => {
  const response = await fetch('/account_session');
  const {client_secret: clientSecret} = await response.json();
  return clientSecret;
}

const stripeConnectInstance = loadConnectAndInitialize({
  publishableKey: 
"pk_test_TYooMQauvdEDq54NiTphI7jx"
,
  fetchClientSecret: fetchClientSecret,
  fonts: [
    {
      cssSrc: "https://myfonts.example.com/mycssfile.css",
    },
    {
      src: `url(https://my-domain.com/assets/my-font-2.woff)`,
      family: 'My Font'
    }
  ],
  appearance: {
    // See all possible variables below
    overlays: "dialog",
    variables: {
      fontFamily: 'My Font',
      colorPrimary: "#FF0000",
    },
  },
});

Das Schriftarten-Objekt

Das fonts-Objekt in stripeConnect.initialize akzeptiert ein Array von CssFontSource- oder CustomFontSource-Objekten.

Wenn Sie auf Ihrer Seite nutzerdefinierte Schriftarten verwenden (d. h. .woff- oder .tff-Dateien), müssen Sie diese Dateien bei der Initialisierung der in Connect eingebetteten Komponenten angeben. Auf diese Weise können die in Connect eingebetteten Komponenten diese Schriftarten ordnungsgemäß rendern. Sie können diese wie folgt angeben:

CssFontSource

Verwenden Sie dieses Objekt, um eine Stylesheet-URL zu übergeben, die Ihre nutzerdefinierten Schriftarten definiert, wenn Sie eine StripeConnectInstance erstellen. Bei einem CssFontSource-Objekt muss Ihre CSP-Konfiguration das Abrufen der Domains, die mit den als CssFontSource angegebenen CSS-Datei-URLs verbunden sind, gestatten.

Name
Typ
Beispielwert
cssSrc
Zeichenfolge required
https://fonts.googleapis.com/css?family=Open+Sans
Eine relative oder absolute URL, die auf eine CSS-Datei mit @font-face-Definitionen verweist. Die Verwendung einer Sicherheitsrichtlinie für Inhalte (CSP) könnte zusätzliche Richtlinien auferlegen.

CustomFontSource

Verwenden Sie dieses Objekt, um Ihre nutzerdefinierten Schriftarten beim Erstellen einer StripeConnectInstance zu übergeben.

Name
Typ
Beispielwert
family
Zeichenfolge required
Avenir
Der Name, der der Schriftart gegeben werden soll.
src
Zeichenfolge required
url(https://my-domain.com/assets/avenir.woff)
Ein gültiger src-Wert, der auf Ihre nutzerdefinierte Schriftartdatei verweist. Dies ist in der Regel (jedoch nicht immer) ein Link zu einer Datei mit dem Suffix .woff , .otf oder .svg.
display
Zeichenfolge optional
auto
Ein gültiger font-display-Wert.
style
Zeichenfolge optional
normal
normal , italic oder oblique .
unicodeRange
Zeichenfolge optional
U+0-7F
Ein gültiger unicode-range-Wert.
weight
Zeichenfolge optional
400
Ein gültiges font-weight. Beachten Sie, dass dies eine Zeichenfolge ist, keine Zahl.

Das Erscheinungsbild-Objekt

Das appearance-Objekt in loadConnectAndInitialize akzeptiert die folgenden optionalen Eigenschaften:

Name
Typ
Beispielwert
overlays
‘dialog’ (Standard) | ‘drawer’
dialog
Der im Connect.js-Designsystem verwendete Overlay-Typ. Legen Sie dies entweder als Dialogfeld oder als Drawer fest.
variables
Objekt
{colorPrimary: "#0074D4"}
Siehe die vollständige Liste der Darstellungsvariablen.

In Connect eingebettete Komponenten nach der Initialisierung aktualisieren

Die Methode update unterstützt die Aktualisierung von in Connect eingebetteten Komponenten nach der Initialisierung. Dies ist nützlich, um die Darstellungsoptionen zur Laufzeit zu wechseln (ohne die Seite zu aktualisieren). Verwenden Sie dazu dasselbe stripeConnectInstance-Objekt, das Sie mit initialize erstellt haben, und rufen Sie die Methode update dafür auf:

index.js
stripeConnectInstance.update({
  appearance: {
    variables: {
      colorPrimary: "#FF0000",
    },
  },
  locale: 'en-US',
});

Notiz

Nicht alle Optionen (z. B. fonts) lassen sich aktualisieren. Die unterstützten Optionen für diese Methode sind eine Teilmenge der in initialize angebotenen Optionen. Dadurch wird die Aktualisierung von appearance und locale unterstützt.

Breite und Höhe

Die in Connect eingebetteten Komponenten verhalten sich wie normale block-HTML-Elemente. Standardmäßig nehmen sie 100 % der width ihres übergeordneten HTML-Elements ein und wachsen entsprechend dem darin gerenderten Inhalt in die Höhe. Sie können die width der in Connect eingebetteten Komponenten steuern, indem Sie die width des übergeordneten HTML-Objekts angeben. Sie können die height nicht direkt steuern, da diese vom gerenderten Inhalt abhängt. Sie können die Höhe jedoch mit maxHeight und overflow: scroll begrenzen, genau wie bei anderen HTML-block-Elementen.

Authentifizierung

Wir bieten eine Reihe von APIs zur Verwaltung von Kontositzungen und Nutzeranmeldedaten in den in Connect eingebetteten Komponenten.

Client-Geheimnis aktualisieren

Bei Sitzungen mit langer Laufzeit kann die Sitzung aus dem ursprünglich angegebenen Client-Geheimnis ablaufen. Wenn sie abläuft, verwenden wir automatisch fetchClientSecret, um ein neues Client-Geheimnis abzurufen und die Sitzung zu aktualisieren. Sie müssen keine zusätzlichen Parameter übergeben.

index.js
import { loadConnectAndInitialize } from "@stripe/connect-js";
// Example method to retrieve the client secret from your server
const fetchClientSecret = async () => {
  const response = await fetch('/account_session');
  const {client_secret: clientSecret} = await response.json();
  return clientSecret;
}

const stripeConnectInstance = loadConnectAndInitialize({
  publishableKey: "{{PUBLISHABLE_KEY}}",
  fetchClientSecret: fetchClientSecret,
});

Abmelden

Wir empfehlen, dass Sie logout für die stripeConnectInstance abrufen, um das zugehörige Kontositzungs-Objekt zu löschen, nachdem sich eine Nutzerin/ein Nutzer von Ihrer App abgemeldet hat. Dadurch werden alle in Connect eingebetteten Komponenten deaktiviert, die zu dieser stripeConnectInstance verlinken.

index.js
// Call this when your user logs out
stripeConnectInstance.logout();

CSP- und HTTP-Header-Anforderungen

Wenn Ihre Website eine Sicherheitsrichtlinie für Inhalte implementiert, müssen Sie die Richtlinie aktualisieren, indem Sie die folgenden Regeln hinzufügen:

  • frame-src https://connect-js.stripe.com https://js.stripe.com
  • img-src https://*.stripe.com
  • script-src https://connect-js.stripe.com https://js.stripe.com
  • style-src sha256-0hAheEzaMe6uXIKV4EehS9pu1am1lj/KnnzrOYqckXk= (SHA eines leeren Style-Elements)

Wenn Sie eine CSS-Datei zum Laden von Web-Fonts zur Nutzung mit in Connect eingebetteten Komponenten verwenden, muss die entsprechende URL durch Ihre CSP-Direktive connect-src zugelassen sein.

Durch Festlegen bestimmter HTTP-Antwort-Header wird die volle Funktionalität der in Connect eingebetteten Komponenten aktiviert:

  • Cross-Origin-Opener-Policy, unsafe-none. Dies (unsafe-none) ist der Standardwert der Kopfzeile, daher funktioniert es, auch ohne die Kopfzeile festzulegen. Andere Werte wie same-origin unterbrechen die Nutzerauthentifizierung in eingebetteten Connect-Komponenten.

Unterstützte Browser

Wir unterstützen dieselben Browser, die derzeit vom Stripe-Dashboard unterstützt werden:

  • Die letzten 20 Hauptversionen von Chrome und Firefox
  • Die letzten beiden Hauptversionen von Safari und Edge
  • Die letzten beiden Hauptversionen von Mobile Safari für iOS

Eingebettete Connect-Komponenten werden nur in Webbrowsern unterstützt und können nicht in eingebetteten Webansichten in mobilen oder Desktop-Anwendungen verwendet werden.

Lokalisierung

Beim Initialisieren von Connect.js können Sie einen locale-Parameter übergeben. Um das Gebietsschema einer eingebetteten Komponente an das Gebietsschema Ihrer Website anzupassen, übergeben Sie den Parameter locale mit dem Gebietsschema der Nutzeroberfläche, die Ihre Website rendert.

Der Standardwert des Parameters locale wird durch das vom Browser konfigurierte Gebietsschema bestimmt. Wenn das angegebene Gebietsschema nicht direkt unterstützt wird, wird eine passende Alternative verwendet (so würde fr-be z. B. wahrscheinlich auf fr-fr zurückgreifen).

Eingebettete Connect-Komponenten unterstützen die folgenden Gebietsschemen:

SpracheGebietsschema-Code
Bulgarisch (Bulgarien)bg-BG
Chinesisch (Vereinfacht)zh-Hans
Chinesisch (Traditionell – Hongkong)zh-Hant-HK
Chinesisch (Traditionell – Taiwan)zh-Hant-TW
Kroatisch (Kroatien)hr-HR
Tschechisch (Tschechien)cs-CZ
Dänisch (Dänemark)da-DK
Niederländisch (Niederlande)nl-NL
Englisch (Australien)en-AU
Englisch (Indien)en-IN
Englisch (Irland)en-IE
Englisch (Neuseeland)en-NZ
Englisch (Singapur)en-SG
Englisch (Vereinigtes Königreich)en-GB
Englisch (USA)en-US
Estnisch (Estland)et-EE
Philippinisch (Philippinen)fil-PH
Finnisch (Finnland)fi-FI
Französisch (Kanada)fr-CA
Französisch (Frankreich)fr-FR
Deutsch (Deutschland)de-DE
Griechisch (Griechenland)el-GR
Ungarisch (Ungarn)hu-HU
Indonesisch (Indonesien)id-ID
Italienisch (Italien)it-IT
Japanisch (Japan)ja-JP
Koreanisch (Südkorea)ko-KR
Lettisch (Lettland)lv-LV
Litauisch (Litauen)lt-LT
Malaiisch (Malaysia)ms-MY
Maltesisch (Malta)mt-MT
Norwegisch, Bokmål (Norwegen)nb-NO
Polnisch (Polen)pl-PL
Portugiesisch (Brasilien)pt-BR
Portugiesisch (Portugal)pt-PT
Rumänisch (Rumänien)ro-RO
Slowakisch (Slowakei)sk-SK
Slowenisch (Slowenien)sl-SI
Spanisch (Argentinien)es-AR
Spanisch (Brasilien)es-BR
Spanisch (Lateinamerika)es-419
Spanisch (Mexiko)es-MX
Spanisch (Spanien)es-ES
Schwedisch (Schweden)sv-SE
Thai (Thailand)th-TH
Türkisch (Türkiye)tr-TR
Vietnamesisch (Vietnam)vi-VN

Umgang mit Fehlern beim Laden

Wenn eine Komponente nicht geladen werden kann, können Sie auf den Fehler reagieren, indem Sie einer eingebetteten Komponente einen Load Error Handler zur Verfügung stellen. Je nach Fehlerursache kann der Load Error Handler mehrfach aufgerufen werden. Jede Logik, die durch einen Load Error Handler ausgelöst wird, muss idempotent sein.

index.js
// Load errors are emitted by all components. We use Balances as an example here.
const balances = stripeConnectInstance.create('balances');
balances.setOnLoadError((loadError) => {
  const componentName = loadError.elementTagName
  const error = loadError.error

  console.log(componentName + " failed to load")
  console.log(`${error.type}: ${error.message}`);
});

container.appendChild(balances);
MethodDescriptionVariables
setOnLoadErrorThe component executes this callback function when a load failure occurs.
  • loadError.error: See the load error object
  • loadError.elementTagName: The name of HTML tag used to render the component in the browser

The load error object

Every time there’s a load failure, an error object is passed to the load error handler with the following properties.

Name
Type
Example value
type
See types of load failures
authentication_error
The type of error
message
string | undefined
Failed to fetch account session
Further description about the error

Types of load failures

When a component fails to load, we detect the type of failure and map it to one of the types below. If the load error type can’t be determined it is marked as an api_error.

TypeDescription
api_connection_errorFailure to connect to Stripe’s API
authentication_errorFailure to perform the authentication flow within Connect embedded components
account_session_create_errorAccount session creation failed
invalid_request_errorRequest failed with an 4xx status code, typically caused by platform configuration issues
rate_limit_errorRequest failed because an abnormal request rate was detected
api_errorAPI errors covering any other type of problem, such as a temporary problem with Stripe’s servers

Anzeige eingebetteter Komponenten erkennen

Nachdem eine Komponente erstellt wurde, wird auf Nutzerseite erst dann eine Nutzeroberfläche angezeigt, wenn das Javascript für die Komponente geladen und im Browser analysiert wurde. Dies kann dazu führen, dass Komponenten nach Abschluss des Ladevorgangs angezeigt werden. Um dies zu vermeiden, zeigen Sie Ihre eigene Ladenutzeroberfläche an, bevor die Komponente erstellt wird, und blenden die Nutzeroberfläche aus, nachdem die Komponente angezeigt wurde. Alle eingebetteten Komponenten können eine Rückruf-Funktion akzeptieren, die unmittelbar vor der Anzeige einer Nutzeroberfläche aufgerufen wird.

index.html
<span id="spinner"></span>
<div id="balances-container"></div>
index.js
// Loader start events are emitted by all components. We use Balances as an example here.
const container = document.getElementById('balances-container');
const balances = stripeConnectInstance.create('balances');

balances.setOnLoaderStart((event) => {
  container.getElementById("spinner").display = "none";
  console.log(`${event.elementTagName} is visible to users`)
});

container.appendChild(balances);
MethodDescriptionVariables
setOnLoaderStartThe component executes this callback function before any UI is displayed to the user.
  • event.elementTagName: The name of HTML tag used to render the component in the browser

Integration ohne Frontend-NPM-Pakete durchführen

Wir empfehlen die Integration mit unseren Javascript- und React-Komponenten-Wrappern, die das Laden der in Connect eingebetteten Komponenten vereinfachen und TypeScript-Definitionen für unsere unterstützten Schnittstellen bereitstellen. Wenn Ihr Build-System derzeit keine Abhängigkeiten von Paketen unterstützt, können Sie die Integration auch ohne diese Pakete durchführen.

Fügen Sie das Connect.js-Skript-Tag manuell zum <head> jeder Seite Ihrer Website hinzu.

<!-- Somewhere in your site's <head> -->
<script src="https://connect-js.stripe.com/v1.0/connect.js" async></script>

Connect.js ohne NPM verwenden

Nachdem Connect.js geladen wurde, wird die globale Fenstervariable StripeConnect initialisiert und StripeConnect.onLoad aufgerufen, sofern von Ihnen definiert. Sie können Connect.js sicher initialisieren, indem Sie eine onload-Funktion einrichten und StripeConnect.init mit denselben Connect.js-Optionen wie loadConnectAndInitialize aufrufen.

index.js
window.StripeConnect = window.StripeConnect || {};
StripeConnect.onLoad = () => {
  const stripeConnectInstance = StripeConnect.init({
      // This is a placeholder - it should be replaced with your publishable API key.
      // Sign in to see your own test API key embedded in code samples.
      // Don’t submit any personally identifiable information in requests made with this key.
      publishableKey: 
"pk_test_TYooMQauvdEDq54NiTphI7jx"
,
      fetchClientSecret: fetchClientSecret,
    });

  const payments = stripeConnectInstance.create('payments');
  document.body.appendChild(payments);
};

Nutzerauthentifizierung in eingebetteten Connect-Komponenten

Für eingebettete Connect-Komponenten ist in der Regel keine Nutzerauthentifizierung erforderlich. In einigen Fällen müssen sich die verbundenen Konten im Rahmen der eingebetteten Connect-Komponenten jedoch mit ihrem Stripe-Konto anmelden, um die erforderlichen Funktionen bereitzustellen (so müssen z. B. den juristischen Personen im Fall einer Komponente des Konto-Onboardings Informationen zugeschrieben werden.

Bei der Authentifizierung wird ein Pop-up-Fenster in einem Stripe-Fenster angezeigt. Das verbundene Konto muss sich authentifizieren, bevor es seinen Workflow fortsetzen kann.

Die folgenden Komponenten erfordern die Authentifizierung verbundener Konten in bestimmten Szenarien:

Andere Komponenten erfordern möglicherweise eine Authentifizierung innerhalb der Komponente, nachdem sie ursprünglich gerendert wurden. Die Authentifizierung für diese Komponenten und Szenarien ist für verbundene Konten erforderlich, bei denen Stripe für die Erfassung aktualisierter Informationen verantwortlich ist, wenn sich die Anforderungen ändern. Für verbundene Konten, bei denen Sie dafür verantwortlich sind, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern, wird die Stripe-Authentifizierung von der Account-Session-Funktion disable_stripe_user_authentication gesteuert. Wir empfehlen die Implementierung von 2FA oder gleichwertigen Sicherheitsmaßnahmen als Best Practice. Bei Kontokonfigurationen, die diese Funktion unterstützen, wie zum Beispiel „Nutzerspezifisch“, übernehmen Sie die Haftung für verbundene Konten, wenn diese keine negativen Guthaben begleichen können.

War diese Seite hilfreich?
JaNein
Benötigen Sie Hilfe? Kontaktieren Sie den Kundensupport.
Nehmen Sie an unserem Programm für frühzeitigen Zugriff teil.
Schauen Sie sich unseren Produkt-Changelog an.
Fragen? Sales-Team kontaktieren.
Unterstützt von Markdoc
Auf dieser Seite
Connect.js initialisieren
AccountSession erstellen
Create Account Session API
Connect.js einrichten
Connect.js laden und initialisieren
Connect.js konfigurieren
Erscheinungsbild der in Connect eingebetteten Komponenten anpassen
Das Schriftarten-Objekt
Das Erscheinungsbild-Objekt
In Connect eingebettete Komponenten nach der Initialisierung aktualisieren
Breite und Höhe
Authentifizierung
Client-Geheimnis aktualisieren
Abmelden
CSP- und HTTP-Header-Anforderungen
Unterstützte Browser
Lokalisierung
Umgang mit Fehlern beim Laden
Anzeige eingebetteter Komponenten erkennen
Integration ohne Frontend-NPM-Pakete durchführen
Connect.js ohne NPM verwenden
Nutzerauthentifizierung in eingebetteten Connect-Komponenten
Verwendete Produkte
Connect