# Connect-Integration erstellen

# Konten zum Onboarding bei Ihrer Connect-Plattform einladen

Erstellen Sie ein verbundenes Konto und sammeln Sie Informationen davon, um Zahlungen zu ermöglichen. Wir empfehlen, Immobilien auszuwählen, bevor Sie eine Beispiel-App herunterladen, da sich Ihre Integration erheblich ändern wird.

const stripe = 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.
  'sk_INSERT_YOUR_SECRET_KEY'
);
const stripe = 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.
  'sk_INSERT_YOUR_SECRET_KEY'
);
app.post("/account/:account", async (req, res) => {
  try {
    const connectedAccountId = req.params.account;

    const account = await stripe.accounts.update(
      connectedAccountId,
      {
        business_type: 'individual',
      },
    );


    res.json({
      account: account.id,
    });
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to update an account",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account/:account", async (req, res) => {
  try {
    const connectedAccountId = req.params.account;

    const account = await stripe.v2.core.accounts.update(
      connectedAccountId,
      {

        identity: {
          entity_type: 'individual',
        },
        include: ['identity'],
      },
    );

    res.json({
      account: account.id,
    });
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to update an account",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account_link", async (req, res) => {
  try {
    const { account } = req.body;

    const accountLink = await stripe.accountLinks.create({
      account: account,
      return_url: `${req.headers.origin}/return/${account}`,
      refresh_url: `${req.headers.origin}/refresh/${account}`,
      type: "account_onboarding",
    });

    res.json(accountLink);
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to create an account link:",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account_link", async (req, res) => {
  try {
    const { account } = req.body;

    const accountLink = await stripe.v2.core.accountLinks.create({
      account: account,
      use_case: {
        type: 'account_onboarding',
        account_onboarding: {
          configurations: ['recipient'],
          configurations: ['merchant'],
          return_url: `${req.headers.origin}/return/${account}`,
          refresh_url: `${req.headers.origin}/refresh/${account}`,
        }
      }
    });
    res.json(accountLink);
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to create an account link:",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account_session", async (req, res) => {
  try {
    const { account } = req.body;

    const accountSession = await stripe.accountSessions.create({
      account: account,
      components: {
        account_onboarding: { enabled: true },
        account_management: {enabled: true},
        notification_banner: {enabled: true},
      },
    });

    res.json({
      client_secret: accountSession.client_secret,
    });
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to create an account session",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account", async (req, res) => {
  try {
    const account = await stripe.accounts.create({});
    const account = await stripe.accounts.create({
      controller: {
        stripe_dashboard: {
          type: "none",
        },
        stripe_dashboard: {
          type: "express",
        },
        fees: {
          payer: "application"
        },
        losses: {
          payments: "application"
        },
        requirement_collection: "application",
        losses: {
          payments: "application"
        },
      },
      capabilities: {
        card_payments: {requested: true},
        transfers: {requested: true}
      },
      capabilities: {
        transfers: {requested: true}
      },
      country: "US",
    });

    res.json({
      account: account.id,
    });
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to create an account",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
app.post("/account", async (req, res) => {
  try {
    const account = await stripe.v2.core.accounts.create({
      dashboard: 'none',
      dashboard: 'express',
      dashboard: 'full',
      contact_email: 'person@example.com',
      defaults: {
        responsibilities: {
          fees_collector: 'application',
          fees_collector: 'stripe',
          losses_collector: 'application',
          losses_collector: 'stripe',
        },
      },
      configuration: {
        merchant: {
          capabilities: {
            card_payments: {
              requested: true,
            },
          },
        },
        recipient: {
          capabilities: {
            stripe_balance: {
              stripe_transfers: {
                requested: true,
              },
            },
          },
        },        
      },
      identity: {
        country: 'US',
      },
      include: [
        'configuration.merchant',
        'configuration.recipient',
        'identity',
        'defaults',
      ],
    });

    res.json({
      account: account.id,
    });
  } catch (error) {
    console.error(
      "An error occurred when calling the Stripe API to create an account",
      error
    );
    res.status(500);
    res.send({ error: error.message });
  }
});
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.
api_key = 'sk_INSERT_YOUR_SECRET_KEY'
$CLIENT = Stripe::StripeClient.new(api_key)
post '/account/:account' do
  content_type 'application/json'

  begin
    connected_account_id = params[:account]
    account = $CLIENT.v1.accounts.update(
      connected_account_id,
      {
        business_type: 'individual',
      }
    )

    {
      account: account[:id]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to update an account: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
post '/account/:account' do
  content_type 'application/json'

  begin
    connected_account_id = params[:account]
    account = $CLIENT.v2.core.accounts.update(
      connected_account_id,
      {
        identity: {
          entity_type: 'individual',
        },
        include: ['identity'],
      },
    )

    {
      account: account[:id]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to update an account: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
post '/account_link' do
  content_type 'application/json'

  body = JSON.parse(request.body.read)
  connected_account_id = body["account"]

  begin
    account_link = $CLIENT.v1.account_links.create({
      account: connected_account_id,
      return_url: "http://localhost:4242/return/#{connected_account_id}",
      refresh_url: "http://localhost:4242/refresh/#{connected_account_id}",
      type: "account_onboarding",
    })

    {
      url: account_link.url
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account link: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
post '/account_link' do
  content_type 'application/json'

  body = JSON.parse(request.body.read)
  connected_account_id = body["account"]

  begin
    account_link = $CLIENT.v2.core.account_links.create({
      account: connected_account_id,
      use_case: {
        type: "account_onboarding",
        account_onboarding: {
          configurations: ['recipient'],
          configurations: ['merchant'],
          return_url: "http://localhost:4242/return/#{connected_account_id}",
          refresh_url: "http://localhost:4242/refresh/#{connected_account_id}",
        }
      }
    })

    {
      url: account_link.url
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account link: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
post '/account_session' do
  content_type 'application/json'

  body = JSON.parse(request.body.read)
  connected_account_id = body["account"]

  begin
    account_session = $CLIENT.v1.account_sessions.create({
      account: connected_account_id,
      components: {
        account_onboarding: {enabled: 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
post '/account_session' do
  content_type 'application/json'

  body = JSON.parse(request.body.read)
  connected_account_id = body["account"]

  begin
    account_session = $CLIENT.v1.account_sessions.create({
      account: connected_account_id,
      components: {
        account_onboarding: {enabled: 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
post '/account' do
  content_type 'application/json'

  begin
    account = $CLIENT.v1.accounts.create
    account = $CLIENT.v1.accounts.create({
      controller: {
        stripe_dashboard: {
          type: "none",
        },
        stripe_dashboard: {
          type: "express",
        },
        fees: {
          payer: "application"
        },
        losses: {
          payments: "application"
        },
        requirement_collection: "application",
        losses: {
          payments: "application"
        },
      },
      capabilities: {
        card_payments: {requested: true},
        transfers: {requested: true}
      },
      capabilities: {
        transfers: {requested: true}
      },
      country: "US",
    })

    {
      account: account[:id]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
post '/account' do
  content_type 'application/json'

  begin
    account = $CLIENT.v2.core.accounts.create({
      dashboard: 'none',
      dashboard: 'express',
      dashboard: 'full',
      contact_email: 'person@example.com',
      defaults: {
        responsibilities: {
          fees_collector: 'application',
          fees_collector: 'stripe',
          losses_collector: 'application'
          losses_collector: 'stripe'
        },
      },
      configuration: {
        merchant: {
          capabilities: {
            card_payments: {requested: true},
          }
        },
        recipient: {
          capabilities: {
            stripe_balance: {
              stripe_transfers: {requested: true},
            },
          }
        },
      },
      identity: {
        country: "US",
      },
      include: [
        'configuration.merchant',
        'configuration.recipient',
        'identity',
        'defaults',
      ],
    })

    {
      account: account[:id]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
  "fmt"
  "context"
  "github.com/stripe/stripe-go/v84"
  "github.com/stripe/stripe-go/v84/accountsession"
// 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.
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
var client = stripe.NewClient("<<YOUR_SECRET_KEY>>")
    r.HandleFunc("/account", CreateAccount)
    r.HandleFunc("/account_session", CreateAccountSession)
    r.HandleFunc("/account_link", CreateAccountLink);
    r.HandleFunc("/account/{account}", UpdateAccount);
func CreateAccountSession(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var requestBody RequestBody
  err := json.NewDecoder(r.Body).Decode(&requestBody)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }

  params := &stripe.AccountSessionCreateParams{
    Account: stripe.String(requestBody.Account),
    Components: &stripe.AccountSessionCreateComponentsParams{
      AccountOnboarding: &stripe.AccountSessionCreateComponentsAccountOnboardingParams{
        Enabled: stripe.Bool(true),
      },
    },
  }

  accountSession, err := client.V1AccountSessions.Create(context.TODO(), params)

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to create an account session: %v", err)
    handleError(w, err)
    return
  }

  writeJSON(w, struct {
    ClientSecret string `json:"client_secret"`
  }{
    ClientSecret: accountSession.ClientSecret,
  })
}
func CreateAccountSession(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var requestBody RequestBody
  err := json.NewDecoder(r.Body).Decode(&requestBody)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }

  params := &stripe.AccountSessionCreateParams{
    Account: stripe.String(requestBody.Account),
    Components: &stripe.AccountSessionCreateComponentsParams{
      AccountOnboarding: &stripe.AccountSessionCreateComponentsAccountOnboardingParams{
        Enabled: stripe.Bool(true),
      },
    },
  }

  accountSession, err := client.V1AccountSessions.Create(context.TODO(), params)

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to create an account session: %v", err)
    handleError(w, err)
    return
  }

  writeJSON(w, struct {
    ClientSecret string `json:"client_secret"`
  }{
    ClientSecret: accountSession.ClientSecret,
  })
}
func UpdateAccount(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  connectedAccountId := mux.Vars(r)["account"]

  params := &stripe.AccountUpdateParams{
    BusinessType: stripe.String("individual"),
  }

  account, err := client.V1Accounts.Update(context.TODO(), connectedAccountId, params)

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to update an account: %v", err)
    handleError(w, err)
    return
  }

  writeJSON(w, struct {
    Account string `json:"account"`
  }{
    Account: account.ID,
  })
}
func UpdateAccount(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  connectedAccountId := mux.Vars(r)["account"]

  params := &stripe.V2CoreAccountUpdateParams{
    Identity: &stripe.V2CoreAccountUpdateIdentityParams{
      EntityType: stripe.String("individual"),
    },
    Include: []*string{stripe.String("identity")},
  }

  account, err := client.V2CoreAccounts.Update(context.TODO(), connectedAccountId, params)

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to update an account: %v", err)
    handleError(w, err)
    return
  }

  writeJSON(w, struct {
    Account string `json:"account"`
  }{
    Account: account.ID,
  })
}
func CreateAccountLink(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var requestBody RequestBody
  err := json.NewDecoder(r.Body).Decode(&requestBody)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }

  accountLink, err := client.V1AccountLinks.Create(context.TODO(), &stripe.AccountLinkCreateParams{
    Account: stripe.String(requestBody.Account),
    ReturnURL: stripe.String(fmt.Sprintf("http://localhost:4242/return/%s", requestBody.Account)),
    RefreshURL: stripe.String(fmt.Sprintf("http://localhost:4242/refresh/%s", requestBody.Account)),
    Type: stripe.String("account_onboarding"),
  })

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to create an account link: %v", err)
    handleError(w, err)
    return
  }
  writeJSON(w, struct {
    URL string `json:"url"`
  }{
    URL: accountLink.URL,
  })
}
func CreateAccountLink(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var requestBody RequestBody
  err := json.NewDecoder(r.Body).Decode(&requestBody)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }

  accountLink, err := client.V2CoreAccountLinks.Create(context.TODO(), &stripe.V2CoreAccountLinkCreateParams{
    Account: stripe.String(requestBody.Account),
    UseCase: &stripe.V2CoreAccountLinkCreateUseCaseParams{
      Type: stripe.String("account_onboarding"),
      AccountOnboarding: &stripe.V2CoreAccountLinkCreateUseCaseAccountOnboardingParams{
        Configurations: []*string{stripe.String("recipient")},
        Configurations: []*string{stripe.String("merchant")},
        ReturnURL: stripe.String(fmt.Sprintf("http://localhost:4242/return/%s", requestBody.Account)),
        RefreshURL: stripe.String(fmt.Sprintf("http://localhost:4242/refresh/%s", requestBody.Account)),
      },
    },
  })

  if err != nil {
    log.Printf("An error occurred when calling the Stripe API to create an account link: %v", err)
    handleError(w, err)
    return
  }
  writeJSON(w, struct {
    URL string `json:"url"`
  }{
    URL: accountLink.URL,
  })
}
  account, err := client.V1Accounts.Create(context.TODO(), &stripe.AccountCreateParams{})
  account, err := client.V1Accounts.Create(context.TODO(), &stripe.AccountCreateParams{
    Controller: &stripe.AccountCreateControllerParams{
      StripeDashboard: &stripe.AccountCreateControllerStripeDashboardParams{
        Type: stripe.String("none"),
      },
      StripeDashboard: &stripe.AccountCreateControllerStripeDashboardParams{
        Type: stripe.String("express"),
      },
      Fees: &stripe.AccountCreateControllerFeesParams{
        Payer: stripe.String("application"),
      },
      Losses: &stripe.AccountCreateControllerLossesParams{
        Payments: stripe.String("application"),
      },
      RequirementCollection: stripe.String("application"),
      Losses: &stripe.AccountCreateControllerLossesParams{
        Payments: stripe.String("application"),
      },
    },
    Capabilities: &stripe.AccountCreateCapabilitiesParams{
      CardPayments: &stripe.AccountCreateCapabilitiesCardPaymentsParams{
        Requested: stripe.Bool(true),
      },
      Transfers: &stripe.AccountCreateCapabilitiesTransfersParams{
        Requested: stripe.Bool(true),
      },
    },
    Capabilities: &stripe.AccountCreateCapabilitiesParams{
      Transfers: &stripe.AccountCreateCapabilitiesTransfersParams{
        Requested: stripe.Bool(true),
      },
    },
    Country: stripe.String("US"),
  })
  account, err := client.V2CoreAccounts.Create(context.TODO(), &stripe.V2CoreAccountCreateParams{
    Dashboard: stripe.String("none"),
    Dashboard: stripe.String("express"),
    Dashboard: stripe.String("full"),
    ContactEmail: stripe.String("person@example.com"),
    Defaults: &stripe.V2CoreAccountCreateDefaultsParams{
      Responsibilities: &stripe.V2CoreAccountCreateDefaultsResponsibilitiesParams{
        FeesCollector: stripe.String("application"),
        FeesCollector: stripe.String("stripe"),
        LossesCollector: stripe.String("application"),
        LossesCollector: stripe.String("stripe"),
      },
    },
    Configuration: &stripe.V2CoreAccountCreateConfigurationParams{
      Merchant: &stripe.V2CoreAccountCreateConfigurationMerchantParams{
        Capabilities: &stripe.V2CoreAccountCreateConfigurationMerchantCapabilitiesParams{
          CardPayments: &stripe.V2CoreAccountCreateConfigurationMerchantCapabilitiesCardPaymentsParams{
            Requested: stripe.Bool(true),
          },
        },
      },
      Recipient: &stripe.V2CoreAccountCreateConfigurationRecipientParams{
        Capabilities: &stripe.V2CoreAccountCreateConfigurationRecipientCapabilitiesParams{
          StripeBalance: &stripe.V2CoreAccountCreateConfigurationRecipientCapabilitiesStripeBalanceParams{
            StripeTransfers: &stripe.V2CoreAccountCreateConfigurationRecipientCapabilitiesStripeBalanceStripeTransfersParams{
              Requested: stripe.Bool(true),
            },
          },
        },
      },
    },
    Identity: &stripe.V2CoreAccountCreateIdentityParams{
      Country: stripe.String("US"),
    },
    Include: []*string{
      stripe.String("configuration.merchant"),
      stripe.String("configuration.recipient"),
      stripe.String("identity"),
      stripe.String("defaults"),
    },
  })
import java.util.HashMap;
import java.util.Map;
import com.stripe.StripeClient;
import com.stripe.model.Account;
import com.stripe.param.AccountCreateParams;
import com.stripe.model.AccountLink;
import com.stripe.param.AccountLinkCreateParams;
import com.stripe.model.AccountSession;
import com.stripe.param.AccountSessionCreateParams;
import com.stripe.param.AccountUpdateParams;
import com.stripe.StripeClient;
import com.stripe.model.v2.core.Account;
import com.stripe.param.v2.core.AccountCreateParams;
import com.stripe.model.v2.core.AccountLink;
import com.stripe.param.v2.core.AccountLinkCreateParams;
import com.stripe.model.AccountSession;
import com.stripe.param.AccountSessionCreateParams;
import com.stripe.param.v2.core.AccountUpdateParams;
  // This is a public sample test API key.
  // Don’t submit any personally identifiable information in requests made with this key.
  // Sign in to see your own test API key embedded in code samples.
  // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
  private static StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");
    post("/account", Server::createAccount);
    post("/account_session", Server::createAccountSession);
    post("/account_link", Server::createAccountLink);
    post("/account/:account", Server::updateAccount);
  private static class UpdateAccountResponse {
    public UpdateAccountResponse() {}
  }

  private static String updateAccount(Request request, Response response) {
    response.type("application/json");

    try {
      String connectedAccountId = request.params("account");

      client.v1().accounts().update(connectedAccountId, AccountUpdateParams.builder()
        .setBusinessType(AccountUpdateParams.BusinessType.INDIVIDUAL)
        .build()
      );

      UpdateAccountResponse accountUpdateResponse = new UpdateAccountResponse();

      return gson.toJson(accountUpdateResponse);
    } catch (Exception e) {
      System.out
          .println("An error occurred when calling the Stripe API to update an account: " + e.getMessage());
      response.status(500);
      return gson.toJson(new ErrorResponse(e.getMessage()));
    }
  }
  private static class UpdateAccountResponse {
    public UpdateAccountResponse() {}
  }

  private static String updateAccount(Request request, Response response) {
    response.type("application/json");

    try {
      String connectedAccountId = request.params("account");

      Account connectedAccount = client.v2().core().accounts().update(connectedAccountId,
        AccountUpdateParams.builder()
        .setIdentity(
          AccountUpdateParams.Identity.builder().
            .setEntityType(AccountUpdateParams.Identity.EntityType.INDIVIDUAL)
        ).build()
        .setBusinessType(AccountUpdateParams.Identity.EntityType.INDIVIDUAL)
        .build()
      );

      UpdateAccountResponse accountUpdateResponse = new UpdateAccountResponse();

      return gson.toJson(accountUpdateResponse);
    } catch (Exception e) {
      System.out
          .println("An error occurred when calling the Stripe API to update an account: " + e.getMessage());
      response.status(500);
      return gson.toJson(new ErrorResponse(e.getMessage()));
    }
  }
  private static class CreateAccountSessionResponse {
    private String client_secret;

    public CreateAccountSessionResponse(String clientSecret) {
      this.client_secret = clientSecret;
    }
  }

  private static String createAccountSession(Request request, Response response) {
    response.type("application/json");

    try {
      String connectedAccountId = gson.fromJson(request.body(), RequestBody.class).getAccount();

      AccountSession accountSession = client.v1().accountSessions().create(
        AccountSessionCreateParams.builder()
          .setAccount(connectedAccountId)
          .setComponents(
            AccountSessionCreateParams.Components.builder()
              .setAccountOnboarding(
                AccountSessionCreateParams.Components.AccountOnboarding.builder()
                  .setEnabled(true)
                  .build()
              )
              .build()
          )
          .build()
      );
      AccountSession accountSession = client.v1().accountSessions().create(
        AccountSessionCreateParams.builder()
          .setAccount(connectedAccountId)
          .setComponents(
            AccountSessionCreateParams.Components.builder()
              .setAccountOnboarding(
                AccountSessionCreateParams.Components.AccountOnboarding.builder()
                  .setEnabled(true)
                  .build()
              )
              .build()
          )
          .build()
      );

      CreateAccountSessionResponse accountSessionResponse = new CreateAccountSessionResponse(
        accountSession.getClientSecret()
      );
      return gson.toJson(accountSessionResponse);
    } catch (Exception e) {
      System.out
          .println("An error occurred when calling the Stripe API to create an account session: " + e.getMessage());
      response.status(500);
      return gson.toJson(new ErrorResponse(e.getMessage()));
    }
  }
  private static class CreateAccountLinkResponse {
    private String url;

    public CreateAccountLinkResponse(String url) {
      this.url = url;
    }
  }

  private static String createAccountLink(Request request, Response response) {
    response.type("application/json");

    try {
      String connectedAccountId = gson.fromJson(request.body(), RequestBody.class).getAccount();

      AccountLink accountLink = client.v1().accountLinks().create(
        AccountLinkCreateParams.builder()
          .setAccount(connectedAccountId)
          .setReturnUrl("http://localhost:4242/return/" + connectedAccountId)
          .setRefreshUrl("http://localhost:4242/refresh/" + connectedAccountId)
          .setType(AccountLinkCreateParams.Type.ACCOUNT_ONBOARDING)
          .build()
      );
      AccountLink accountLink = client.v2().core().accountLinks().create(
        AccountLinkCreateParams.builder()
          .setAccount(connectedAccountId)
          .setUseCase(
            AccountLinkCreateParams.UseCase.builder()
              .setType(AccountLinkCreateParams.UseCase.Type.ACCOUNT_ONBOARDING)
              .setAccountOnboarding(
                AccountLinkCreateParams.UseCase.AccountOnboarding.builder()
                  .addConfiguration(
                    AccountLinkCreateParams.UseCase.AccountOnboarding.Configuration.RECIPIENT
                  )
                  .addConfiguration(
                    AccountLinkCreateParams.UseCase.AccountOnboarding.Configuration.MERCHANT
                  )
                  .setReturnUrl("http://localhost:4242/return/" + connectedAccountId)
                  .setRefreshUrl("http://localhost:4242/refresh/" + connectedAccountId)
                  .build()
              )
              .build()
          )
          .build()
      );

      CreateAccountLinkResponse accountLinkResponse = new CreateAccountLinkResponse(accountLink.getUrl());
      return gson.toJson(accountLinkResponse);
    } catch (Exception e) {
      System.out.println("An error occurred when calling the Stripe API to create an account link: " + e.getMessage());
      response.status(500);
      return gson.toJson(new ErrorResponse(e.getMessage()));
    }
  }
      Account account = client.v1().accounts().create(AccountCreateParams.builder().build());
      Account account = client.v1().accounts().create(
        AccountCreateParams.builder()
          .setController(AccountCreateParams.Controller.builder()
            .setStripeDashboard(
              AccountCreateParams.Controller.StripeDashboard.builder()
                .setType(AccountCreateParams.Controller.StripeDashboard.Type.NONE)
                .build()
            )
            .setStripeDashboard(
              AccountCreateParams.Controller.StripeDashboard.builder()
                .setType(AccountCreateParams.Controller.StripeDashboard.Type.EXPRESS)
                .build()
            )
            .setFees(
              AccountCreateParams.Controller.Fees.builder()
                .setPayer(AccountCreateParams.Controller.Fees.Payer.APPLICATION)
                .build()
            )
            .setLosses(
              AccountCreateParams.Controller.Losses.builder()
                .setPayments(AccountCreateParams.Controller.Losses.Payments.APPLICATION)
                .build()
            )
            .setRequirementCollection(AccountCreateParams.Controller.RequirementCollection.APPLICATION)
            .setLosses(
              AccountCreateParams.Controller.Losses.builder()
                .setPayments(AccountCreateParams.Controller.Losses.Payments.APPLICATION)
                .build()
            )
            .build()
          )
          .setCapabilities(
            AccountCreateParams.Capabilities.builder()
              .setCardPayments(
                AccountCreateParams.Capabilities.CardPayments.builder()
                  .setRequested(true)
                  .build()
              )
              .setTransfers(
                AccountCreateParams.Capabilities.Transfers.builder()
                  .setRequested(true)
                  .build()
              ).build()
          )
          .setCapabilities(
            AccountCreateParams.Capabilities.builder()
              .setTransfers(
                AccountCreateParams.Capabilities.Transfers.builder()
                  .setRequested(true)
                  .build()
              ).build()
          )
          .setCountry("US")
        .build()
      );
      Account account = client.v2().core().accounts().create(
        AccountCreateParams.builder()
            .setDashboard(AccountCreateParams.Dashboard.NONE)
            .setDashboard(AccountCreateParams.Dashboard.EXPRESS)
            .setDashboard(AccountCreateParams.Dashboard.FULL)
            .setContactEmail("person@example.com")
            .setDefaults(
                  AccountCreateParams.Defaults.builder()
                    .setResponsibilities(
                      AccountCreateParams.Defaults.Responsibilities.builder()
                        .setFeesCollector(
                          AccountCreateParams.Defaults.Responsibilities.FeesCollector.APPLICATION
                        )
                        .setFeesCollector(
                          AccountCreateParams.Defaults.Responsibilities.FeesCollector.STRIPE
                        )
                        .setLossesCollector(
                          AccountCreateParams.Defaults.Responsibilities.LossesCollector.APPLICATION
                        )
                        .setLossesCollector(
                          AccountCreateParams.Defaults.Responsibilities.LossesCollector.STRIPE
                        )
                        .build()
                    )
                    .build()
                )
            .setConfiguration(
              AccountCreateParams.Configuration.builder()
                .setMerchant(
                  AccountCreateParams.Configuration.Merchant.builder()
                    .setCapabilities(
                      AccountCreateParams.Configuration.Merchant.Capabilities.builder()
                        .setCardPayments(
                          AccountCreateParams.Configuration.Merchant.Capabilities.CardPayments.builder()
                            .setRequested(true)
                            .build()
                        )
                        .build()
                    )
                    .build()
                )
                .setRecipient(
                  AccountCreateParams.Configuration.Recipient.builder()
                    .setCapabilities(
                      AccountCreateParams.Configuration.Recipient.Capabilities.builder()
                        .setStripeBalance(
                          AccountCreateParams.Configuration.Recipient.Capabilities.StripeBalance.builder()
                            .setStripeTransfers(
                              AccountCreateParams.Configuration.Recipient.Capabilities.StripeBalance.StripeTransfers.builder()
                                .setRequested(true)
                                .build()
                            )
                            .build()
                        )
                        .build()
                    )
                    .build()
                )
                .build()
            )
            .setIdentity(
              AccountCreateParams.Identity.builder()
                .setCountry("US")
                .build()
            )
            .addInclude(AccountCreateParams.Include.CONFIGURATION__MERCHANT)
            .addInclude(AccountCreateParams.Include.CONFIGURATION__RECIPIENT)
            .addInclude(AccountCreateParams.Include.IDENTITY)
            .addInclude(AccountCreateParams.Include.DEFAULTS)
            .build()
          );
import 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.
client = stripe.StripeClient('sk_INSERT_YOUR_SECRET_KEY')
\# 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.
api_key = 'sk_INSERT_YOUR_SECRET_KEY'
client = stripe.StripeClient(api_key)
@app.route('/account/<account>', methods=['POST'])
def update_account(account):
    try:
        connected_account = client.v1.accounts.update(
          account,
          params={
            'business_type': 'individual',
          },
        )

        return jsonify({
          'account': connected_account.id,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to update an account: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account/<account>', methods=['POST'])
def update_account(account):
    try:
        connected_account = client.v2.core.accounts.update(
          account,
          {
            "identity": {
              "entity_type": "individual",
            },
          }
        )

        return jsonify({
          'account': connected_account.id,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to update an account: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account_link', methods=['POST'])
def create_account_link():
    try:
        connected_account_id = request.get_json().get('account')

        account_link = client.v1.account_links.create(params={
          'account': connected_account_id,
          'return_url': f"http://localhost:4242/return/{connected_account_id}",
          'refresh_url': f"http://localhost:4242/refresh/{connected_account_id}",
          'type': 'account_onboarding',
        })

        return jsonify({
          'url': account_link.url,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account link: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account_link', methods=['POST'])
def create_account_link():
    try:
        connected_account_id = request.get_json().get('account')

        account_link = client.v2.core.account_links.create({
          "account": connected_account_id,
          "use_case": {
            "type": "account_onboarding",
            "account_onboarding": {
              "configurations": ["recipient"],
              "configurations": ["merchant"],
              "return_url": f"http://localhost:4242/return/{connected_account_id}",
              "refresh_url": f"http://localhost:4242/refresh/{connected_account_id}",
            },
          },
        })

        return jsonify({
          'url': account_link.url,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account link: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account_session', methods=['POST'])
def create_account_session():
    try:
        connected_account_id = request.get_json().get('account')

        account_session = client.v1.account_sessions.create(params={
          'account': connected_account_id,
          'components': {
            "account_onboarding": {"enabled": True},
          },
        })

        return jsonify({
          'client_secret': account_session.client_secret,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account session: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account_session', methods=['POST'])
def create_account_session():
    try:
        connected_account_id = request.get_json().get('account')

        account_session = client.v1.account_sessions.create({
          "account": connected_account_id,
          "components": {
            "account_onboarding": {"enabled": True},
          },
        })

        return jsonify({
          'client_secret': account_session.client_secret,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account session: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account', methods=['POST'])
def create_account():
    try:
        account = client.v1.accounts.create()
        account = client.v1.accounts.create(params={
          'controller': {
            "stripe_dashboard": {
              "type": "none",
            },
            "stripe_dashboard": {
              "type": "express",
            },
            "fees": {
              "payer": "application"
            },
            "losses": {
              "payments": "application"
            },
            "requirement_collection": "application",
            "losses": {
              "payments": "application"
            },
          },
          'capabilities': {
            "card_payments": {"requested": True},
            "transfers": {"requested": True}
          },
          'capabilities': {
            "transfers": {"requested": True}
          },
          'country': "US",
        })

        return jsonify({
          'account': account.id,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account: ', e)
        return jsonify(error=str(e)), 500
@app.route('/account', methods=['POST'])
def create_account():
    try:
        account = client.v2.core.accounts.create({
          "dashboard": "none",
          "dashboard": "express",
          "dashboard": "full",
          "contact_email": "person@example.com",
          "defaults": {
            "responsibilities": {
              "fees_collector": "application",
              "fees_collector": "stripe",
              "losses_collector": "application",
              "losses_collector": "stripe",
            },
          },
          "configuration": {            
            "merchant": {
              "capabilities": {
                "card_payments": { "requested": True },
              }
            },
            "recipient": {
              "capabilities": {
                "stripe_balance": {
                  "stripe_transfers": { "requested": True },
                }
              }
            },
          },          
          "identity": {
            "country": "US",
          },        
          "include": [
            "configuration.merchant",
            "configuration.recipient",
            "identity",
            "defaults",
          ]
        })

        return jsonify({
          'account': account.id,
        })
    except Exception as e:
        print('An error occurred when calling the Stripe API to create an account: ', e)
        return jsonify(error=str(e)), 500
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient([
  // This is your test secret API key.
  "api_key" => $stripeSecretKey,
]);

try {
  $account = $stripe->accounts->create();
  $account = $stripe->accounts->create([
    'controller' => [
      'stripe_dashboard' => [
        'type' => 'none',
      ],
      'stripe_dashboard' => [
        'type' => 'express',
      ],
      'fees' => [
        'payer' => 'application'
      ],
      'losses' => [
        'payments' => 'application'
      ],
      'requirement_collection' => 'application',
      'losses' => [
        'payments' => 'application'
      ],
    ],
    'capabilities' => [
      'card_payments' => ['requested' => true],
      'transfers' => ['requested' => true],
    ],
    'capabilities' => [
      'transfers' => ['requested' => true],
    ],
    'country' => "US",
  ]);

  echo json_encode(array(
    'account' => $account->id
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}

?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient($stripeSecretKey);

try {
  $account = $stripe->v2->core->accounts->create([
    'dashboard' => 'none',
    'dashboard' => 'express',
    'dashboard' => 'full',
    'contact_email' => 'person@example.com',
    'defaults' => [
      'responsibilities' => [
        'fees_collector' => 'application',
        'fees_collector' => 'stripe',
        'losses_collector' => 'application',
        'losses_collector' => 'stripe',
      ],
    ],
    'configuration' => [
      'merchant' => ['capabilities' => ['card_payments' => ['requested' => true]]],
      'recipient' => [
        'capabilities' => ['stripe_balance' => ['stripe_transfers' => ['requested' => true]]],
      ],
    ],
    'identity' => [
      'country' => "US",
    ],
    'include' => [
      'configuration.merchant',
      'configuration.recipient',
      'identity',
      'defaults',
    ],    
  ]);

  echo json_encode(array(
    'account' => $account->id
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}
?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient([
  // This is your test secret API key.
  "api_key" => $stripeSecretKey,
]);

$json = file_get_contents('php://input');
$data = json_decode($json);

if ($data && $data->account) {
  try {
    $account = $stripe->accounts->update(
      $data->account,
      ['business_type' => 'individual'],
    );

    echo json_encode(array(
      'account' => $account->id
    ));
    return;
  } catch (Exception $e) {
    error_log("An error occurred when calling the Stripe API to update an account: {$e->getMessage()}");
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
  }
} else {
  try {
    $account = $stripe->accounts->create();
    $account = $stripe->accounts->create([
      'controller' => [
        'stripe_dashboard' => [
          'type' => 'none',
        ],
        'stripe_dashboard' => [
          'type' => 'express',
        ],
        'fees' => [
          'payer' => 'application'
        ],
        'losses' => [
          'payments' => 'application'
        ],
        'requirement_collection' => 'application',
        'losses' => [
          'payments' => 'application'
        ],
      ],
      'capabilities' => [
        'card_payments' => ['requested' => true],
        'transfers' => ['requested' => true],
      ],
      'capabilities' => [
        'transfers' => ['requested' => true],
      ],
      'country' => "US",
    ]);

    echo json_encode(array(
      'account' => $account->id
    ));
  } catch (Exception $e) {
    error_log("An error occurred when calling the Stripe API to create an account: {$e->getMessage()}");
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
  }
}

?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient($stripeSecretKey);

$json = file_get_contents('php://input');
$data = json_decode($json);

if ($data && $data->account) {
  try {
    $account = $stripe->v2->core->accounts->update(
      $data->account,
      [
        'identity' => [
          'entity_type' => 'individual'
        ]
      ]
    );

    echo json_encode(array(
      'account' => $account->id
    ));
    return;
  } catch (Exception $e) {
    error_log("An error occurred when calling the Stripe API to update an account: {$e->getMessage()}");
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
  }
} else {
  try {
    $account = $stripe->v2->core->accounts->create([
      'dashboard' => 'none',
      'dashboard' => 'express',
      'dashboard' => 'full',
      'contact_email' => 'person@example.com',
      'defaults' => [
        'responsibilities' => [
          'fees_collector' => 'application',
          'fees_collector' => 'stripe',
          'losses_collector' => 'application',
          'losses_collector' => 'stripe',
        ],
      ],
      'configuration' => [
        'merchant' => ['capabilities' => ['card_payments' => ['requested' => true]]],
        'recipient' => [
          'capabilities' => ['stripe_balance' => ['stripe_transfers' => ['requested' => true]]],
        ],
      ],
      'identity' => [
        'country' => "US",
      ],
      'include' => [
        'configuration.merchant',
        'configuration.recipient',
        'identity',
        'defaults',
      ],    
    ]);

    echo json_encode(array(
      'account' => $account->id
    ));
  } catch (Exception $e) {
    error_log("An error occurred when calling the Stripe API to create an account: {$e->getMessage()}");
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
  }
}
?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient([
  // This is your test secret API key.
  "api_key" => $stripeSecretKey,
]);

try {
  $json = file_get_contents('php://input');
  $data = json_decode($json);

  $account_session = $stripe->accountSessions->create([
    'account' => $data->account,
    'components' => [
      'account_onboarding' => [
        'enabled' => true,
      ],
    ],
  ]);

  echo json_encode(array(
    'client_secret' => $account_session->client_secret
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account session: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}

?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient($stripeSecretKey);

try {
  $json = file_get_contents('php://input');
  $data = json_decode($json);

  $account_session = $stripe->accountSessions->create([
    'account' => $data->account,
    'components' => [
      'account_onboarding' => [
        'enabled' => true,
      ],
    ],
  ]);

  echo json_encode(array(
    'client_secret' => $account_session->client_secret
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account session: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}

?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient([
  // This is your test secret API key.
  "api_key" => $stripeSecretKey,
]);

try {
  $json = file_get_contents('php://input');
  $data = json_decode($json);
  $connectedAccountId = $data->account;

  $account_link = $stripe->accountLinks->create([
    'account' => $connectedAccountId,
    'return_url' => sprintf("http://localhost:4242/return/%s", $connectedAccountId),
    'refresh_url' => sprintf("http://localhost:4242/refresh/%s", $connectedAccountId),
    'type' => 'account_onboarding',
  ]);

  echo json_encode(array(
    'url' => $account_link->url
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account link: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}

?>
<?php

require_once '../vendor/autoload.php';
require_once '../secrets.php';

header('Content-Type: application/json');

$stripe = new \Stripe\StripeClient(
  $stripeSecretKey
);

try {
  $json = file_get_contents('php://input');
  $data = json_decode($json);
  $connectedAccountId = $data->account;

  $account_link = $stripe->v2->core->accountLinks->create([
    'account' => $connectedAccountId,
    'use_case' => [
      'type' => 'account_onboarding',
      'account_onboarding' => [
        'configurations' => ['recipient'],
        'configurations' => ['merchant'],
        'return_url' => sprintf("http://localhost:4242/return/%s", $connectedAccountId),
        'refresh_url' => sprintf("http://localhost:4242/refresh/%s", $connectedAccountId),
      ],
    ],
  ]);

  echo json_encode(array(
    'url' => $account_link->url
  ));
} catch (Exception $e) {
  error_log("An error occurred when calling the Stripe API to create an account link: {$e->getMessage()}");
  http_response_code(500);
  echo json_encode(['error' => $e->getMessage()]);
}

?>
// 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.
$stripeSecretKey = 'sk_INSERT_YOUR_SECRET_KEY';
using Stripe;
            // This is a public sample test API key.
            // Don’t submit any personally identifiable information in requests made with this key.
            // Sign in to see your own test API key embedded in code samples.
            // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
            services.AddSingleton(new StripeClient("<<YOUR_SECRET_KEY>>"));
        [HttpPost("{connectedAccountId}")]
        public ActionResult Update(string connectedAccountId)
        {
            try
            {
                Account account = _client.V1.Accounts.Update(
                    connectedAccountId,
                    new AccountUpdateOptions
                    {
                      BusinessType = "individual",
                    }
                );

                return Json(new { account = account.Id });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to update an account:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
        [HttpPost("{connectedAccountId}")]
        public ActionResult Update(string connectedAccountId)
        {
            try
            {
                var options = new Stripe.V2.Core.AccountUpdateOptions
                {
                    Identity = new Stripe.V2.Core.AccountUpdateIdentityOptions
                    {
                        EntityType = "individual",
                    },
                    Include = new List<string> { "identity" },
                };
                var service = _client.V2.Core.Accounts;
                Stripe.V2.Core.Account account = service.Update(connectedAccountId, options);

                return Json(new { account = account.Id });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to update an account:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }

        [HttpPost]
        public ActionResult Create()
        {
            try
            {
                var options = new AccountCreateOptions();
                var options = new AccountCreateOptions
                {
                    Controller = new AccountControllerOptions
                    {
                        StripeDashboard = new AccountControllerStripeDashboardOptions
                        {
                            Type = "none"
                        },
                        StripeDashboard = new AccountControllerStripeDashboardOptions
                        {
                            Type = "express"
                        },
                        Fees = new AccountControllerFeesOptions
                        {
                            Payer = "application"
                        },
                        Losses = new AccountControllerLossesOptions
                        {
                            Payments = "application"
                        },
                        RequirementCollection = "application",
                        Losses = new AccountControllerLossesOptions
                        {
                            Payments = "application"
                        },
                    },
                    Capabilities = new AccountCapabilitiesOptions
                    {
                        CardPayments = new AccountCapabilitiesCardPaymentsOptions
                        {
                            Requested = true,
                        },
                        Transfers = new AccountCapabilitiesTransfersOptions
                        {
                            Requested = true,
                        },
                    },
                    Capabilities = new AccountCapabilitiesOptions
                    {
                        Transfers = new AccountCapabilitiesTransfersOptions
                        {
                            Requested = true,
                        },
                    },
                    Country = "US",
                };

                Account account = _client.V1.Accounts.Create(options);

                return Json(new { account = account.Id });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
        [HttpPost]
        public ActionResult Create()
        {
            try
            {

                var options = new Stripe.V2.Core.AccountCreateOptions
                {

                    Dashboard = "none",
                    Dashboard = "express",
                    Dashboard = "full",
                    ContactEmail = "person@example.com",
                    Defaults = new Stripe.V2.Core.AccountCreateDefaultsOptions
                    {
                        Responsibilities = new Stripe.V2.Core.AccountCreateDefaultsResponsibilitiesOptions
                        {
                            FeesCollector = "application",
                            FeesCollector = "stripe",
                            LossesCollector = "application",
                            LossesCollector = "stripe",
                        },
                    },
                    Configuration = new Stripe.V2.Core.AccountCreateConfigurationOptions
                    {
                        Merchant = new Stripe.V2.Core.AccountCreateConfigurationMerchantOptions
                        {
                            Capabilities = new Stripe.V2.Core.AccountCreateConfigurationMerchantCapabilitiesOptions
                            {
                                CardPayments = new Stripe.V2.Core.AccountCreateConfigurationMerchantCapabilitiesCardPaymentsOptions
                                {
                                    Requested = true,
                                },
                            },
                        },
                        Recipient = new Stripe.V2.Core.AccountCreateConfigurationRecipientOptions
                        {
                            Capabilities = new Stripe.V2.Core.AccountCreateConfigurationRecipientCapabilitiesOptions
                            {
                                StripeBalance = new Stripe.V2.Core.AccountCreateConfigurationRecipientCapabilitiesStripeBalanceOptions
                                {
                                    StripeTransfers = new Stripe.V2.Core.AccountCreateConfigurationRecipientCapabilitiesStripeBalanceStripeTransfersOptions
                                    {
                                      Requested = true,
                                    }
                                },
                            },
                        },
                    },
                    Identity = new Stripe.V2.Core.AccountCreateIdentityOptions
                    {
                        Country = "US",
                    },
                    Include = new List<string>
                    {
                        "configuration.merchant",
                        "configuration.recipient",
                        "identity",
                        "defaults",
                    },
                };

                var service = _client.V2.Core.Accounts;
                Stripe.V2.Core.Account account = service.Create(options);
                return Json(new { account = account.Id });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
    public class AccountSessionPostBody
    {
        public string Account { get; set; }
    }

    [Route("account_session")]
    [ApiController]
    public class AccountSessionApiController : Controller
    {
        private readonly StripeClient _client;

        public AccountSessionApiController(StripeClient client)
        {
          _client = client;
        }

        [HttpPost]
        public ActionResult Create([FromBody] AccountSessionPostBody accountSessionPostBody)
        {
            try
            {
                var connectedAccountId = accountSessionPostBody.Account;

                AccountSession accountSession = _client.V1.AccountSessions.Create(
                    new AccountSessionCreateOptions
                    {
                        Account = connectedAccountId,
                        Components = new AccountSessionComponentsOptions
                        {
                            AccountOnboarding = new AccountSessionComponentsAccountOnboardingOptions
                            {
                                Enabled = true
                            },
                        }
                    }
                );

                return Json(new { client_secret = accountSession.ClientSecret });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account session:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
    }
    [Route("account_session")]
    [ApiController]
    public class AccountSessionApiController : Controller
    {
        private StripeClient _client;

        public AccountSessionApiController(StripeClient client)
        {
          _client = client;
        }

        [HttpPost]
        public ActionResult Create([FromBody] AccountSessionPostBody accountSessionPostBody)
        {
            try
            {
                var connectedAccountId = accountSessionPostBody.Account;

                var service = _client.V1.AccountSessions;

                AccountSession accountSession = service.Create(
                    new AccountSessionCreateOptions
                    {
                        Account = connectedAccountId,
                        Components = new AccountSessionComponentsOptions
                        {
                            AccountOnboarding = new AccountSessionComponentsAccountOnboardingOptions
                            {
                                Enabled = true
                            },
                        }
                    }
                );
                return Json(new { client_secret = accountSession.ClientSecret });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account session:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
    }
     public class AccountLinkPostBody
    {
        public string Account { get; set; }
    }

    [Route("account_link")]
    [ApiController]
    public class AccountLinkApiController : Controller
    {
        private readonly StripeClient _client;

        public AccountLinkApiController(StripeClient client)
        {
          _client = client;
        }

        [HttpPost]
        public ActionResult Create([FromBody] AccountLinkPostBody accountLinkPostBody)
        {
            try
            {
                var connectedAccountId = accountLinkPostBody.Account;

                AccountLink accountLink = _client.V1.AccountLinks.Create(
                    new AccountLinkCreateOptions
                    {
                        Account = connectedAccountId,
                        ReturnUrl = $"http://localhost/return/{connectedAccountId}",
                        RefreshUrl = $"http://localhost/refresh/{connectedAccountId}",
                        Type = "account_onboarding",
                    }
                );

                return Json(new { url = accountLink.Url });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account link:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
    }
    [Route("account_link")]
    [ApiController]
    public class AccountLinkApiController : Controller
    {
        private StripeClient _client;

        public AccountLinkApiController(StripeClient client)
        {
          _client = client;
        }

        [HttpPost]
        public ActionResult Create([FromBody] AccountLinkPostBody accountLinkPostBody)
        {
            try
            {
                var connectedAccountId = accountLinkPostBody.Account;
                var options = new Stripe.V2.Core.AccountLinkCreateOptions
                {
                    Account = connectedAccountId,
                    UseCase = new Stripe.V2.Core.AccountLinkCreateUseCaseOptions
                    {
                        Type = "account_onboarding",
                        AccountOnboarding = new Stripe.V2.Core.AccountLinkCreateUseCaseAccountOnboardingOptions
                        {
                            Configurations = new List<string> { "recipient" },
                            Configurations = new List<string> { "merchant" },
                            ReturnUrl = $"http://localhost/return/{connectedAccountId}",
                            RefreshUrl = $"http://localhost/refresh/{connectedAccountId}",
                        },
                    },
                };
                var service = _client.V2.Core.AccountLinks;
                Stripe.V2.Core.AccountLink accountLink = service.Create(options);
                return Json(new { url = accountLink.Url });
            } catch(Exception ex) {
                Console.Write("An error occurred when calling the Stripe API to create an account link:  " + ex.Message);
                Response.StatusCode = 500;
                return Json(new { error = ex.Message });
            }
        }
    }
certifi==2026.1.4
chardet==5.2.0
click==8.3.1
Flask==3.1.2
idna==3.11
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==3.0.3
requests==2.32.5
stripe==15.0.0
toml==0.10.2
Werkzeug==3.1.5
          <h2>Rocket Rides</h2>
          <p id="subtitle">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
          <p id="add-information-subtitle" class="hidden">Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>
          <div id="example-form" class="example-form hidden">
            <h2>Your onboarding flow goes here</h2>
          </div>
          <h2>Rocket Rides</h2>
          <p id="subtitle">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
          <h2>Rocket Rides</h2>
          <p id="subtitle">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
          <p id="add-information-subtitle" class="hidden">Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>
          <h2 id="details-submitted-title" class="hidden">Details submitted</h2>
          <p id="details-submitted-subtitle" class="hidden">That's everything we need for now</p>
  fetch("/account.php", {
  fetch("/account", {
    method: "POST",
  })
    .then((response) => response.json())
    .then((json) => {
      const {account, error} = json;

      if (error) {
        document.getElementById("error").classList.remove("hidden");
        document.getElementById("sign-up-button").classList.remove("hidden");
        document.getElementById("creating-connected-account").classList.add("hidden");
        document.getElementById("dev-callout").classList.add("hidden");
        return;
      }

      connectedAccountId = account;

      const connectedAccountIdElement = document.getElementById("connected-account-id");
      connectedAccountIdElement.innerHTML = `Your connected account ID is: <code class="bold">${connectedAccountId}</code>`;
      connectedAccountIdElement.classList.remove("hidden");

      document.getElementById("add-information-button").classList.remove("hidden");
      document.getElementById("creating-connected-account").classList.add("hidden");
      document.getElementById("title").classList.add("hidden");
      document.getElementById("subtitle").classList.add("hidden");
      document.getElementById("add-information-title").classList.remove("hidden");
      document.getElementById("add-information-subtitle").classList.remove("hidden");
    });
  fetch("/account.php", {
  fetch(`/account/${connectedAccountId}`, {
    method: "POST",
  })
    .then((response) => response.json())
    .then((json) => {
      const {error} = json;

      if (error) {
        document.getElementById("error").classList.remove("hidden");
        document.getElementById("adding-onboarding-information").classList.add("hidden");
        document.getElementById("add-information-button").classList.remove("hidden");
        return;
      }

      document.getElementById("example-form").classList.remove("hidden");
      document.getElementById("onboarding-has-begun").classList.remove("hidden");
      document.getElementById("adding-onboarding-information").classList.add("hidden");
    });
import { loadConnectAndInitialize } from "@stripe/connect-js";
  const response = await fetch('/account_session.php', {
  const response = await fetch('/account_session', {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      account: connectedAccountId,
    }),
  });
  fetch("/account.php", {
  fetch("/account", {
    method: "POST",
  })
    .then((response) => response.json())
    .then((json) => {
      const {account, error} = json;

      if (error) {
        document.getElementById("error").classList.remove("hidden");
        document.getElementById("sign-up-button").classList.remove("hidden");
        document.getElementById("creating-connected-account").classList.add("hidden");
        document.getElementById("dev-callout").classList.add("hidden");
        return;
      }

      connectedAccountId = account;

      const connectedAccountIdElement = document.getElementById("connected-account-id");
      connectedAccountIdElement.innerHTML = `Your connected account ID is: <code class="bold">${connectedAccountId}</code>`;
      connectedAccountIdElement.classList.remove("hidden");

      document.getElementById("creating-connected-account").classList.add("hidden");
      document.getElementById("title").classList.add("hidden");
      document.getElementById("subtitle").classList.add("hidden");

      const stripeConnectInstance = loadConnectAndInitialize({
        // Replace this with your publishable API key from https://dashboard.stripe.com/test/apikeys
        publishableKey: "pk_INSERT_YOUR_PUBLISHABLE_KEY",
        fetchClientSecret: fetchClientSecret,
        appearance: {
          overlays: 'dialog',
          variables: {
            colorPrimary: "#635BFF",
          },
        },
      });

      const container = document.getElementById("embedded-onboarding-container");
      const embeddedOnboardingComponent = stripeConnectInstance.create("account-onboarding");
      embeddedOnboardingComponent.setOnExit(() => {
        console.log('User exited the onboarding flow');
      });
      container.appendChild(embeddedOnboardingComponent);
    });
  fetch("/account.php", {
  fetch("/account", {
    method: "POST",
  })
    .then((response) => response.json())
    .then((json) => {
      const {account, error} = json;

      if (error) {
        document.getElementById("error").classList.remove("hidden");
        document.getElementById("sign-up-button").classList.remove("hidden");
        document.getElementById("creating-connected-account").classList.add("hidden");
        document.getElementById("dev-callout").classList.add("hidden");
        return;
      }

      connectedAccountId = account;

      const connectedAccountIdElement = document.getElementById("connected-account-id");
      connectedAccountIdElement.innerHTML = `Your connected account ID is: <code class="bold">${connectedAccountId}</code>`;
      connectedAccountIdElement.classList.remove("hidden");

      document.getElementById("add-information-button").classList.remove("hidden");
      document.getElementById("creating-connected-account").classList.add("hidden");
      document.getElementById("title").classList.add("hidden");
      document.getElementById("subtitle").classList.add("hidden");
      document.getElementById("add-information-title").classList.remove("hidden");
      document.getElementById("add-information-subtitle").classList.remove("hidden");
    });
  fetch("/account_link.php", {
  fetch("/account_link", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      account: connectedAccountId,
    }),
  })
    .then((response) => response.json())
    .then((json) => {
      const {url, error} = json;

      if (error) {
        document.getElementById("error").classList.remove("hidden");
        document.getElementById("add-information-button").classList.remove("hidden");
        return;
      }

      document.getElementById("adding-onboarding-information").classList.add("hidden");
      window.location.href = url;
    });
  document.getElementById("title").classList.add("hidden");
  document.getElementById("subtitle").classList.add("hidden");
  document.getElementById("sign-up-button").classList.add("hidden");
  document.getElementById("details-submitted-title").classList.remove("hidden");
  document.getElementById("details-submitted-subtitle").classList.remove("hidden");
  connectedAccountId = parts[2];
  createAccountLinkAndRedirect(connectedAccountId);
  margin-top: 0;
  margin-bottom: 80px;
  margin: 0;
  background-color: #635BFF;
  color: #ffffff;
.example-form {
  height: 400px;
  width: 420px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  border: 1px dashed black;
  padding: 0;
}
  background-color: #635BFF;
  color: #ffffff;
{
  "name": "stripe-sample-code",
  "version": "1.0.0",
  "description": "Build a full, working Connect integration. Here are some basic scripts you can use to build and run the application.",
  "scripts": {
    "start": "parcel watch",
    "build": "parcel build"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "parcel": "^2.8.3"
  },
  "source": "public/index.html",
  "dependencies": {
    "@stripe/connect-js": "3.3.5"
  }
}
{
  "name": "stripe-sample-code",
  "version": "1.0.0",
  "description": "Build a full, working Connect integration. Here are some basic scripts you can use to build and run the application.",
  "scripts": {
    "start-client": "parcel watch",
    "start-server": "node server.js",
    "start": "concurrently \"yarn start-client\" \"yarn start-server\"",
    "build": "parcel build"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "concurrently": "4.1.2",
    "parcel": "^2.8.3"
  },
  "source": "public/index.html",
  "dependencies": {
    "express": "^4.17.1",
    "stripe": "20.1.0",
    "@stripe/connect-js": "3.3.5"
  }
}
{
    "name": "stripe-sample",
    "version": "0.1.0",
    "dependencies": {
        "@stripe/connect-js": "3.3.5",
        "@stripe/react-connect-js": "3.3.7",
        "express": "^4.17.1",
        "react": "^18.2.0",
        "react-dom": "^18.2.0",
        "react-router-dom": "^6.4.0",
        "react-scripts": "^3.4.0",
        "stripe": "20.1.0"
    },
    "devDependencies": {
        "concurrently": "4.1.2",
        "parcel": "^2.8.3"
    },
    "homepage": "http://localhost:3000",
    "proxy": "http://localhost:4242",
    "source": "public/index.html",
    "scripts": {
        "start-client": "parcel watch",
        "start-server": "node server.js",
        "build": "parcel build",
        "test": "react-scripts test",
        "eject": "react-scripts eject",
        "start": "concurrently \"yarn start-client\" \"yarn start-server\""
    },
    "eslintConfig": {
        "extends": "react-app"
    },
    "browserslist": {
        "production": [
            ">0.2%",
            "not dead",
            "not op_mini all"
        ],
        "development": [
            "last 1 chrome version",
            "last 1 firefox version",
            "last 1 safari version"
        ]
    }
}
{
  "name": "client",
  "version": "0.1.0",
  "private": true,
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.4.0",
    "react-scripts": "^3.4.0",
    "@stripe/connect-js": "3.3.5",
    "@stripe/react-connect-js": "3.3.7"
  },
  "homepage": "http://localhost:3000",
  "proxy": "http://localhost:4242",
  "scripts": {
    "start": "parcel watch",
    "build": "parcel build"
  },
  "source": "public/index.html",
  "eslintConfig": {
    "extends": "react-app"
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  },
  "devDependencies": {
    "parcel": "^2.8.3"
  }
}
import Refresh from "./Refresh";
import Return from "./Return";
  {
    path: "/refresh/:connectedAccountId",
    element: <Refresh />,
  },
  {
    path: "/return/:connectedAccountId",
    element: <Return />,
  },
export default function App() {
  return (
    <div>
      <RouterProvider router={router} />
    </div>
  );
}
  margin-top: 0;
  margin-bottom: 80px;
  margin: 0;
  background-color: #635BFF;
  color: #ffffff;
.example-form {
  height: 400px;
  width: 420px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  border: 1px dashed black;
  padding: 0;
}
  background-color: #635BFF;
  color: #ffffff;
\# Replace this placeholder with your publishable key from https://dashboard.stripe.com/test/apikeys
REACT_APP_STRIPE_PUBLISHABLE_KEY=pk_INSERT_YOUR_PUBLISHABLE_KEY
export default function Refresh() {
  const {connectedAccountId} = useParams();
  const [accountLinkCreatePending, setAccountLinkCreatePending] = useState(false);
  const [error, setError] = useState(false);

  React.useEffect(() => {
    if (connectedAccountId) {
      setAccountLinkCreatePending(true);
        fetch("/account_link.php", {
        fetch("/account_link", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          account: connectedAccountId,
        }),
      })
        .then((response) => response.json())
        .then((json) => {
          setAccountLinkCreatePending(false);

          const { url, error } = json;

          if (url) {
            window.location.href = url;
          }

          if (error) {
            setError(true);
          }
        });
    }
  }, [connectedAccountId])

  return (
    <div className="container">
      <div className="banner">
        <h2>Rocket Rides</h2>
      </div>
      <div className="content">
        <h2>Add information to start accepting money</h2>
        <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
        {error && <p className="error">Something went wrong!</p>}
      </div>
      <div className="dev-callout">
        {connectedAccountId && <p>Your connected account ID is: <code className="bold">{connectedAccountId}</code></p>}
        {accountLinkCreatePending && <p>Creating a new Account Link...</p>}
      </div>
    </div>
  );
}
export default function Return() {
  const {connectedAccountId} = useParams();

  return (
    <div className="container">
      <div className="banner">
        <h2>Rocket Rides</h2>
      </div>
      <div className="content">
        <h2>Details submitted</h2>
        <p>That's everything we need for now</p>
      </div>
      <div className="info-callout">
        <p>
        This is a sample app for Stripe-hosted Connect onboarding. <a href="https://docs.stripe.com/connect/onboarding/quickstart?connect-onboarding-surface=hosted" target="_blank" rel="noopener noreferrer">View docs</a>
        </p>
      </div>
    </div>
  );
}
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
        {connectedAccountId && <p>Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>}
              onClick={async () => {
                setAccountCreatePending(true);
                setError(false);
                fetch("/account.php", {
                  method: "POST",
                })
                fetch("/account", {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountCreatePending(false);
                    const connectedAccountId = json.account;
                    setConnectedAccountId(connectedAccountId);
                  });
              }}
              onClick={async () => {
                setAccountUpdatePending(true);
                setError(false);
                fetch(`/account.php`, {
                  method: "POST",
                  headers: {
                    "Content-Type": "application/json",
                  },
                  body: JSON.stringify({
                    account: connectedAccountId,
                  }),
                })
                fetch(`/account/${connectedAccountId}`, {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountUpdatePending(false);
                    setConnectedAccountUpdated(true);
                  });
              }}
        {connectedAccountUpdated && (
          <div className="example-form">
            <h2>Your onboarding flow goes here</h2>
          </div>
        )}
import {
  ConnectAccountOnboarding,
  ConnectComponentsProvider,
} from "@stripe/react-connect-js";
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
              onClick={async () => {
                setAccountCreatePending(true);
                setError(false);
                fetch("/account.php", {
                  method: "POST",
                })
                fetch("/account", {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountCreatePending(false);
                    const { account, error } = json;

                    if (account) {
                      setConnectedAccountId(account);
                    }

                    if (error) {
                      setError(true);
                    }
                  });
              }}
          <ConnectComponentsProvider connectInstance={stripeConnectInstance}>
            <ConnectAccountOnboarding
              onExit={() => setOnboardingExited(true)}
            />
          </ConnectComponentsProvider>
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
        {connectedAccountId && <p>Matt's Mats partners with Stripe to help you receive payments and keep your personal bank and details secure.</p>}
            onClick={async () => {
              setAccountCreatePending(true);
              setError(false);
              fetch("/account.php", {
                method: "POST",
              })
              fetch("/account", {
                method: "POST",
              })
                .then((response) => response.json())
                .then((json) => {
                  setAccountCreatePending(false);

                  const { account, error } = json;

                  if (account) {
                    setConnectedAccountId(account);
                  }

                  if (error) {
                    setError(true);
                  }
                });
            }}
            onClick={async () => {
              setAccountLinkCreatePending(true);
              setError(false);
              fetch("/account_link.php", {
              fetch("/account_link", {
                method: "POST",
                headers: {
                  "Content-Type": "application/json",
                },
                body: JSON.stringify({
                  account: connectedAccountId,
                }),
              })
                .then((response) => response.json())
                .then((json) => {
                  setAccountLinkCreatePending(false);

                  const { url, error } = json;
                  if (url) {
                    window.location.href = url;
                  }

                  if (error) {
                    setError(true);
                  }
                });
            }}
import { loadConnectAndInitialize } from "@stripe/connect-js";
export const useStripeConnect = (connectedAccountId) => {
  const [stripeConnectInstance, setStripeConnectInstance] = useState();

  useEffect(() => {
    if (connectedAccountId) {
      const fetchClientSecret = async () => {
        const response = await fetch("/account_session.php", {
        const response = await fetch("/account_session", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            account: connectedAccountId,
          }),
        });

        if (!response.ok) {
          // Handle errors on the client side here
          const { error } = await response.json();
          throw new Error("An error occurred: " + error);
        } else {
          const { client_secret: clientSecret } = await response.json();
          return clientSecret;
        }
      };

      setStripeConnectInstance(
        loadConnectAndInitialize({
          publishableKey: process.env.REACT_APP_STRIPE_PUBLISHABLE_KEY,
          fetchClientSecret,
          appearance: {
            overlays: "dialog",
            variables: {
              colorPrimary: "#635BFF",
            },
          },
        })
      );
    }
  }, [connectedAccountId]);

  return stripeConnectInstance;
};
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
        {connectedAccountId && <p>Matt's Mats partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>}
            onClick={async () => {
              setAccountCreatePending(true);
              setError(false);
              fetch("/api/account", {
                method: "POST",
              })
                .then((response) => response.json())
                .then((json) => {
                  setAccountCreatePending(false);

                  const { account, error } = json;

                  if (account) {
                    setConnectedAccountId(account);
                  }

                  if (error) {
                    setError(true);
                  }
                });
            }}
            onClick={async () => {
              setAccountLinkCreatePending(true);
              setError(false);
              fetch("/api/account_link", {
                method: "POST",
                headers: {
                  "Content-Type": "application/json",
                },
                body: JSON.stringify({
                  account: connectedAccountId,
                }),
              })
                .then((response) => response.json())
                .then((json) => {
                  setAccountLinkCreatePending(false);

                  const { url, error } = json;
                  if (url) {
                    window.location.href = url;
                  }

                  if (error) {
                    setError(true);
                  }
                });
            }}
import {
  ConnectAccountOnboarding,
  ConnectComponentsProvider,
} from "@stripe/react-connect-js";
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
              onClick={async () => {
                setAccountCreatePending(true);
                setError(false);
                fetch("/api/account", {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountCreatePending(false);
                    const { account, error } = json;

                    if (account) {
                      setConnectedAccountId(account);
                    }

                    if (error) {
                      setError(true);
                    }
                  });
              }}
          <ConnectComponentsProvider connectInstance={stripeConnectInstance}>
            <ConnectAccountOnboarding
              onExit={() => setOnboardingExited(true)}
            />
          </ConnectComponentsProvider>
        <h2>Rocket Rides</h2>
        {!connectedAccountId && <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>}
        {connectedAccountId && <p>Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>}
              onClick={async () => {
                setAccountCreatePending(true);
                setError(false);
                fetch("/api/account", {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountCreatePending(false);
                    const connectedAccountId = json.account;
                    setConnectedAccountId(connectedAccountId);
                  });
              }}
              onClick={async () => {
                setAccountUpdatePending(true);
                setError(false);
                fetch(`/api/account/${connectedAccountId}`, {
                  method: "POST",
                })
                  .then((response) => response.json())
                  .then((json) => {
                    setAccountUpdatePending(false);
                    setConnectedAccountUpdated(true);
                  });
              }}
        {connectedAccountUpdated && (
          <div className="example-form">
            <h2>Your onboarding flow goes here</h2>
          </div>
        )}
export default function Refresh() {
  const {query: {id: connectedAccountId}} = useRouter();
  const [accountLinkCreatePending, setAccountLinkCreatePending] = useState(false);
  const [error, setError] = useState(false);

  React.useEffect(() => {
    if (connectedAccountId) {
      setAccountLinkCreatePending(true);
        fetch("/api/account_link", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          account: connectedAccountId,
        }),
      })
        .then((response) => response.json())
        .then((json) => {
          setAccountLinkCreatePending(false);

          const { url, error } = json;

          if (url) {
            window.location.href = url;
          }

          if (error) {
            setError(true);
          }
        });
    }
  }, [connectedAccountId]);

  return (
    <div className="container">
      <div className="banner">
        <h2>Rocket Rides</h2>
      </div>
      <div className="content">
        <h2>Add information to start accepting money</h2>
        <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
        {error && <p className="error">Something went wrong!</p>}
      </div>
      <div className="dev-callout">
        {connectedAccountId && <p>Your connected account ID is: <code className="bold">{connectedAccountId}</code></p>}
        {accountLinkCreatePending && <p>Creating a new Account Link...</p>}
      </div>
    </div>
  );
}
export default function Return() {
  return (
    <div className="container">
      <div className="banner">
        <h2>Rocket Rides</h2>
      </div>
      <div className="content">
        <h2>Details submitted</h2>
        <p>That's everything we need for now</p>
      </div>
      <div className="info-callout">
        <p>
        This is a sample app for Stripe-hosted Connect onboarding. <a href="https://docs.stripe.com/connect/onboarding/quickstart?connect-onboarding-surface=hosted" target="_blank" rel="noopener noreferrer">View docs</a>
        </p>
      </div>
    </div>
  );
}
export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const account = await stripe.accounts.create({});
      const account = await stripe.accounts.create({
        controller: {
          stripe_dashboard: {
            type: "none",
          },
          stripe_dashboard: {
            type: "express",
          },
          fees: {
            payer: "application"
          },
          losses: {
            payments: "application"
          },
          requirement_collection: "application",
          losses: {
            payments: "application"
          },
        },
        capabilities: {
          card_payments: {requested: true},
          transfers: {requested: true}
        },
        capabilities: {
          transfers: {requested: true}
        },
        country: "US",
      });

      res.json({account: account.id});
    } catch (error) {
      console.error('An error occurred when calling the Stripe API to create an account:', error);
      res.status(500);
      res.json({error: error.message});
    }
  }
}
export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const account = await stripe.v2.core.accounts.create({
        dashboard: 'none',
        dashboard: 'express',
        dashboard: 'full',
        contact_email: 'person@example.com',
        defaults: {
          responsibilities: {
            fees_collector: 'application',
            fees_collector: 'stripe',
            losses_collector: 'application',
            losses_collector: 'stripe',
          },
        },
        configuration: {
          merchant: {
            capabilities: {
              card_payments: {
                requested: true,
              },
            },
          },
          recipient: {
            capabilities: {
              stripe_balance: {
                stripe_transfers: {
                  requested: true,
                },
              },
            },
          },
        },
        identity: {
          country: 'US',
        },
        include: [
          'configuration.merchant',
          'configuration.recipient',
          'identity',
          'defaults',
        ],
      });

      res.json({account: account.id});
    } catch (error) {
      console.error('An error occurred when calling the Stripe API to create an account:', error);
      res.status(500);
      res.json({error: error.message});
    }
  }
}
export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const {id: connectedAccountId} = req.query;

      const account = await stripe.accounts.update(
        connectedAccountId,
        {
          business_type: 'individual',
        },
      );

      res.json({
        account: account.id
      });
    } catch (error) {
      console.error('An error occurred when calling the Stripe API to update an account:', error);
      res.status(500);
      res.json({error: error.message});
    }
  }
}
export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const {id: connectedAccountId} = req.query;

      const account = await stripe.v2.core.accounts.update(
        connectedAccountId,
        {
          identity: {
            entity_type: 'individual',
          },
          include: ['identity'],
        },
      );

      res.json({
        account: account.id
      });
    } catch (error) {
      console.error('An error occurred when calling the Stripe API to update an account:', error);
      res.status(500);
      res.json({error: error.message});
    }
  }
}
export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const accountSession = await stripe.accountSessions.create({
        account: req.body.account,
        components: {
          account_onboarding: { enabled: true },
        }
      });

      res.json({
        client_secret: accountSession.client_secret,
      });
    } catch (error) {
      console.error(
        "An error occurred when calling the Stripe API to create an account session",
        error
      );
      res.status(500);
      res.json({error: error.message});
    }
  }
}
export default async function handler(req, res) {
  if (req.method === "POST") {
    try {
      const { account } = req.body;

      const accountLink = await stripe.accountLinks.create({
        account: account,
        refresh_url: `${req.headers.origin}/refresh/${account}`,
        return_url: `${req.headers.origin}/return/${account}`,
        type: "account_onboarding",
      });

      res.json({
        url: accountLink.url,
      });
    } catch (error) {
      console.error(
        "An error occurred when calling the Stripe API to create an account link:",
        error
      );
      res.status(500);
      res.send({ error: error.message });
    }
  }
}
export default async function handler(req, res) {
  if (req.method === "POST") {
    try {
      const { account } = req.body;

      const accountLink = await stripe.v2.core.accountLinks.create({
        account: account,
        use_case: {
          type: 'account_onboarding',
          account_onboarding: {
            configurations: ['recipient'],
            configurations: ['merchant'],
            return_url: `${req.headers.origin}/return/${account}`,
            refresh_url: `${req.headers.origin}/refresh/${account}`,
          }
        }
      });

      res.json(accountLink);
    } catch (error) {
      console.error(
        "An error occurred when calling the Stripe API to create an account link:",
        error
      );
      res.status(500);
      res.send({ error: error.message });
    }
  }
}
import { loadConnectAndInitialize } from "@stripe/connect-js";
export const useStripeConnect = (connectedAccountId) => {
  const [stripeConnectInstance, setStripeConnectInstance] = useState();

  useEffect(() => {
    if (connectedAccountId) {
      const fetchClientSecret = async () => {
        const response = await fetch("/api/account_session", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            account: connectedAccountId,
          }),
        });

        if (!response.ok) {
          // Handle errors on the client side here
          const { error } = await response.json();
          throw new Error("An error occurred: " + error);
        } else {
          const { client_secret: clientSecret } = await response.json();
          return clientSecret;
        }
      };

      setStripeConnectInstance(
        loadConnectAndInitialize({
          publishableKey: process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY,
          fetchClientSecret,
          appearance: {
            overlays: "dialog",
            variables: {
              colorPrimary: "#635BFF",
            },
          },
        })
      );
    }
  }, [connectedAccountId]);

  return stripeConnectInstance;
};
export const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY, {
  apiVersion: '2026-04-22.dahlia',
});
export const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY, {
  apiVersion: '2026-04-22.dahlia',
});
  margin-top: 0;
  margin-bottom: 80px;
  margin: 0;
  background-color: #635BFF;
  color: #ffffff;
.example-form {
  height: 400px;
  width: 420px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  border: 1px dashed black;
  padding: 0;
}
  background-color: #635BFF;
  color: #ffffff;
STRIPE_SECRET_KEY=sk_INSERT_YOUR_SECRET_KEY
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_INSERT_YOUR_PUBLISHABLE_KEY
    "@stripe/connect-js": "3.3.5",
    "@stripe/react-connect-js": "3.3.7",
{
  "name": "stripe-sample",
  "version": "0.1.0",
  "private": true,
  "source": "public/index.html",
  "scripts": {
    "start-client": "parcel watch",
    "start-server": "node server.js",
    "build": "parcel build",
    "start": "concurrently \"yarn start-client\" \"yarn start-server\""
  },
  "dependencies": {
    "@stripe/connect-js": "3.3.13",
    "express": "^4.17.1",
    "stripe": "20.1.0",
    "vue": "^3.2.38",
    "vue-router": "4"
  },
  "devDependencies": {
    "@parcel/transformer-vue": "^2.9.3",
    "concurrently": "4.1.2",
    "parcel": "^2.9.3"
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  }
}
{
  "name": "stripe-sample",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "start": "parcel watch",
    "build": "parcel build"
  },
  "source": "public/index.html",
  "dependencies": {
    "@stripe/connect-js": "3.3.13",
    "vue": "^3.2.38",
    "vue-router": "4"
  },
  "devDependencies": {
    "@parcel/transformer-vue": "^2.9.3",
    "parcel": "^2.9.3"
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  }
}
import Refresh from './components/Refresh.vue'
import Return from './components/Return.vue'
    {
      path: '/refresh/:account',
      name: 'refresh',
      component: Refresh
    },
    {
      path: '/return/:account',
      name: 'return',
      component: Return
    }
      <h2>Rocket Rides</h2>
      <p>Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
      fetch("/account_link.php", {
      fetch("/account_link", {
\# Replace this placeholder with your publishable key from https://dashboard.stripe.com/test/apikeys
VUE_APP_STRIPE_PUBLISHABLE_KEY=pk_INSERT_YOUR_PUBLISHABLE_KEY
      <h2>Rocket Rides</h2>
      <p v-if="!connectedAccountId">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
      <p v-if="connectedAccountId">Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>
      <div v-if="connectedAccountUpdated" class="example-form">
        <h2>Your onboarding flow goes here</h2>
      </div>
    createAccount() {
      this.accountCreatePending = true;
      this.error = false;
      fetch("/account.php", {
      fetch("/account", {
        method: "POST",
      }).then((response) =>
        response.json().then((json) => {
          this.accountCreatePending = false;
          this.connectedAccountId = json.account;
        })
      );
    },
    updateAccount() {
      this.accountUpdatePending = true;
      this.error = false;
      fetch(`/account.php`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          account: this.connectedAccountId,
        }),
      })
      fetch(`/account/${this.connectedAccountId}`, {
        method: "POST",
      })
        .then((response) =>
        response.json().then((json) => {
          this.accountUpdatePending = false;
          this.connectedAccountUpdated = true;
        })
      );
    },
      <h2>Rocket Rides</h2>
      <p v-if="!connectedAccountId">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
    createAccount() {
      this.accountCreatePending = true;
      this.error = false;
      fetch("/account.php", {
      fetch("/account", {
        method: "POST",
      }).then((response) =>
        response.json().then((json) => {
          this.accountCreatePending = false;
          this.connectedAccountId = json.account;

          const fetchClientSecret = async () => {
            const response = await fetch("/account_session.php", {
            const response = await fetch("/account_session", {
              method: "POST",
              headers: {
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                account: this.connectedAccountId,
              }),
            });

            if (!response.ok) {
              // Handle errors on the client side here
              const { error } = await response.json();
              throw new Error("An error occurred: " + error);
            } else {
              const { client_secret: clientSecret } = await response.json();
              return clientSecret;
            }
          };

          this.stripeConnectInstance = loadConnectAndInitialize({
            publishableKey: process.env.VUE_APP_STRIPE_PUBLISHABLE_KEY,
            fetchClientSecret,
            appearance: {
              overlays: "dialog",
              variables: {
                colorPrimary: "#635BFF",
              },
            },
          });

          const container = document.getElementById("embedded-onboarding-container");
          const embeddedOnboardingComponent = this.stripeConnectInstance.create("account-onboarding");
          embeddedOnboardingComponent.setOnExit(() => {
            console.log('User exited the onboarding flow');
          });
          container.appendChild(embeddedOnboardingComponent);
        })
      );
    },
      <h2>Rocket Rides</h2>
      <p v-if="!connectedAccountId">Rocket Rides is the world's leading air travel platform: join our team of pilots to help people travel faster.</p>
      <p v-if="connectedAccountId">Rocket Rides partners with Stripe to help you receive payments while keeping your personal and bank details secure.</p>
    createAccount() {
      this.accountCreatePending = true;
      this.error = false;
      fetch("/account.php", {
      fetch("/account", {
        method: "POST",
      }).then((response) =>
        response.json().then((json) => {
          this.accountCreatePending = false;
          this.connectedAccountId = json.account;
        })
      );
    },
    createAccountLink() {
      this.accountLinkCreatePending = true;
      this.error = false;
      fetch("/account_link.php", {
      fetch("/account_link", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          account: this.connectedAccountId,
        }),
      }).then((response) =>
        response.json().then((json) => {
          this.accountLinkCreatePending = false;

          const { url, error } = json;
          if (url) {
            window.location.href = url;
          }

          if (error) {
            this.error = true;
          }
        })
      );
    },
  margin-top: 0;
  margin-bottom: 80px;
  margin: 0;
  background-color: #635BFF;
  color: #ffffff;
.example-form {
  height: 400px;
  width: 420px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  border: 1px dashed black;
  padding: 0;
}
  background-color: #635BFF;
  color: #ffffff;
- pk_INSERT_YOUR_PUBLISHABLE_KEY
1. Build the server

~~~
pip3 install -r requirements.txt
~~~

2. Run the server

~~~
FLASK_APP=server.py python3 -m flask run --port=4242
~~~
1. Build the server

~~~
bundle install
~~~

2. Run the server

~~~
ruby server.rb -o 0.0.0.0
~~~
1. Build the server

~~~
composer install
~~~

2. Run the server

~~~
php -S 127.0.0.1:4242 --docroot=dist
~~~
1. Build the server

~~~
dotnet restore
~~~

2. Run the server

~~~
dotnet run
~~~
1. Build the server

~~~
mvn package
~~~

2. Run the server

~~~
java -cp target/sample-jar-with-dependencies.jar com.stripe.sample.Server
~~~
1. Install the dependencies

~~
go mod download github.com/stripe/stripe-go/v85
go mod download github.com/gorilla/mux
~~

2. Run the server

~~~
go run server.go
~~~

3. Build the client app

~~~
npm install
~~~

4. Run the client app

~~~
npm start
~~~

5. Go to [http://localhost:4242](http://localhost:4242)
1. Build the application

~~~
npm install
~~~

2. Run the application

~~~
npm start
~~~

3. Go to [http://localhost:4242/index.html](http://localhost:4242/index.html)
1. Build the application

~~~
npm install
~~~

2. Run the application

~~~
npm run dev
~~~

3. Go to [localhost:4242](http://localhost:4242)
### Stripe Node-Bibliothek installieren

Installieren Sie das Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### npm

Installieren Sie die Bibliothek:

```bash
npm install --save stripe@20.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Node-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0) herunter.

### Stripe-Ruby-Bibliothek installieren

Installieren Sie Stripe Ruby Gem und fordern Sie es in Ihrem Code an. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine Gemfile benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Terminal

Installieren Sie das Gem:

```bash
gem install stripe -v 18.1.0
```

#### Bundler

Fügen Sie diese Zeile zu Ihrer Gemfile hinzu:

```bash
gem 'stripe', '18.1.0'
```

#### GitHub

Laden Sie den Quellcode von Stripe Ruby Gem direkt [von GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0) herunter.

### Stripe Java-Bibliothek installieren

Fügen Sie Ihrem Build die Abhängigkeit hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `pom.xml`-Beispieldatei (für Maven) benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Maven

Fügen Sie Ihrem POM die folgende Abhängigkeit hinzu.

```bash
<dependency>\n<groupId>com.stripe</groupId>\n<artifactId>stripe-java</artifactId>\n<version>31.1.0</version>\n</dependency>
```

#### Gradle

Fügen Sie die Abhängigkeit zu Ihrer `build.gradle`-Datei hinzu.

```bash
implementation "com.stripe:stripe-java:31.1.0"
```

#### GitHub

Laden Sie die JAR-Datei direkt [von GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0) herunter.

### Stripe-Python-Paket installieren

Installieren Sie das Stripe-Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `requirements.txt`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### pip

Installieren Sie das Paket über pip:

```bash
pip3 install stripe==14.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Python-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0) herunter.

### Stripe PHP-Bibliothek installieren

Installieren Sie die Bibliothek mit Composer und initialisieren Sie sie mit Ihrem geheimen API-Schlüssel. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `composer.json`-Datei benötigen, laden Sie die Dateien über den Link im Code-Editor herunter.

#### Composer

Installieren Sie die Bibliothek:

```bash
composer require stripe/stripe-php:19.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-php-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0) herunter.

### Installieren Sie die Stripe Go-Bibliothek

Fügen Sie die Abhängigkeit zu Ihrem Build hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen und eine `go.mod`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Go

Initialisieren Sie mit Go-Modulen:

```bash
go get -u github.com/stripe/stripe-go/v85.0.0
```

#### GitHub

Laden Sie den Quellcode des Stripe-Go-Moduls direkt [von GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0) herunter.

### Stripe.net-Bibliothek installieren

Installieren Sie das Paket mit .NET oder NuGet. Wenn Sie aber komplett neu beginnen möchten, laden Sie die Dateien herunter, die eine konfigurierte `.csproj`-Datei enthalten.

#### dotnet

Installieren Sie die Bibliothek:

```bash
dotnet add package Stripe.net --version 50.1.0
```

#### NuGet

Installieren Sie die Bibliothek:

```bash
Install-Package Stripe.net -Version 50.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe.net-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0) herunter.

### Installieren Sie die Stripe Bibliothek

Installieren Sie die Pakete und importieren Sie sie in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

Installieren Sie die Bibliotheken und initialisieren Sie das Stripe SDK mit den richtigen Beta-Headern:

```bash
npm install --save stripe@20.1.0
```

### Übersicht

Ihre Connec-Integration ändert sich erheblich, je nachdem, wie Sie Ihre verbundenen Konten erstellen. Wir haben die Eigenschaften der verbundenen Konten basierend auf Ihren Entscheidungen bei der Einführung Ihres Plattformkontos in Connect angepasst. Die hier vorgenommenen Änderungen aktualisieren nicht Ihre Plattformeinstellungen und werden nicht im Stripe angezeigt.

Siehe [Entwerfen einer Integration](https://docs.stripe.com/connect/interactive-platform-guide.md), um mehr über diese Entscheidungen zu erfahren.

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Leiten Sie Ihre verbundenen Konten über einen Konto-Link zum von Stripe gehosteten Onboarding um.

#### Item 2

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Integrieren Sie die eingebettete Konto-Onboarding-Komponente in die Anwendung Ihrer Plattform.

#### Item 2

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Stellen Sie Verifizierungsinformationen für Ihre verbundenen Konten mithilfe der Stripe-API in einem von Ihnen selbst erstellten Onboarding-Ablauf bereit. Ihre Plattform ist für die Erfassung aktualisierter Informationen verantwortlich, wenn sich Anforderungen ändern oder fällig werden.

Stripe empfiehlt diese Option nur dann, wenn Sie sich voll und ganz über die Komplexität der Erstellung und Wartung eines API-Onboarding-Ablaufs im Klaren sind. Für ein benutzerdefiniertes Onboarding empfiehlt Stripe dringend ein eingebettetes Onboarding.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Geben Sie Ihren verbundenen Konten Zugriff auf das Stripe-Dashboard.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Geben Sie Ihren verbundenen Konten Zugriff auf das Express-Dashboard.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Erstellen Sie eine Kontoverwaltungsschnittstelle für Ihre verbundenen Konten mithilfe der Stripe-API und der [eingebetteten Connect-Komponenten](https://docs.stripe.com/connect/get-started-connect-embedded-components.md).

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Sie erstellen Zahlungen direkt auf Ihren verbundenen Konten.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Destination Charges auf Ihrem Plattformkonto und übertragen Sie Geld auf Ihre verbundenen Konten. Fordern Sie die Funktion `transfers` für Ihre verbundenen Konten an.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Destination Charges auf Ihrem Plattformkonto und übertragen Sie Geld auf Ihre verbundenen Konten.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Zahlungen auf Ihrem Plattformkonto und teilen Sie die jeweiligen Beträge auf mehrere verbundene Konten auf. Fordern Sie die Funktion `transfers` für Ihre verbundenen Konten an.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Zahlungen auf Ihrem Plattformkonto und teilen Sie die jeweiligen Beträge auf mehrere verbundene Konten auf.

#### Item 2

### Wählen Sie aus, wer die Gebühren zahlt

#### Item 1

Stripe zieht die Stripe-Gebühren von Ihren verbundenen Konten ein.

#### Item 2

### Wählen Sie aus, wer die Gebühren zahlt

#### Item 1

Stripe zieht die Stripe-Gebühren von Ihrer Plattform ein. Ihre Plattform kann Zahlungen über Plattformgebühren monetarisieren.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet nicht für negative Kontostände. Stripe ist dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet für negative Kontostände. Ihre Plattform ist auch dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

Bevor Sie Konten mit dieser Einrichtung erstellen, sollten Sie sorgfältig über die Verantwortung Ihrer Plattform für Verbindlichkeiten aus Negativsalden nachdenken und diese anerkennen.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet für negative Kontostände. Stripe ist dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

Bevor Sie Konten mit dieser Einrichtung erstellen, sollten Sie sorgfältig über die Verantwortung Ihrer Plattform für Verbindlichkeiten aus Negativsalden nachdenken und diese anerkennen.

#### Item 2

### Fügen Sie einen Endpoint hinzu, um ein verbundenes Konto zu erstellen.

Richten Sie auf Ihrem Server einen Endpoint ein, den Ihr Client anrufen kann, um die Erstellung eines verbundenen Kontos zu bearbeiten.

### Verbundenes Konto erstellen

Erstellen Sie ein verbundenes Konto, indem Sie die Stripe API aufrufen. Wir haben die verwendeten Attribute basierend auf den oben ausgewählten Einstellungen konfiguriert. Sie können Verifizierungsinformationen, das Geschäftsprofil des Nutzers/der Nutzerin und andere Felder im [Konto](https://docs.stripe.com/api/accounts/create.md) vorab ausfüllen, wenn Ihre Plattform sie bereits erfasst hat.

### Verbundenes Konto erstellen

Erstellen Sie ein verbundenes Konto, indem Sie die Stripe API aufrufen. Wir haben die verwendeten Attribute basierend auf den oben ausgewählten Einstellungen konfiguriert. Sie können Verifizierungsinformationen, das Unternehmensprofil der Nutzerin/des Nutzers sowie weitere Felder im [Konto](https://docs.stripe.com/api/v2/core/accounts/create.md) vorab ausfüllen, wenn Ihre Plattform diese Daten bereits erfasst hat.

### Geben Sie das Land des Kontos an

Wenn Ihre Konten kein von Stripe gehostetes Dashboard verwenden, müssen Sie das Land des Kontos im Voraus angeben.

### Geben Sie das Land des Kontos an

Sie müssen das Feld `identity.country` des Kontos im Voraus angeben.

### Rufen Sie den Endpoint auf, um ein verbundenes Konto zu erstellen.

Rufen Sie den Endpoint auf, den Sie oben hinzugefügt haben, um ein verbundenes Konto zu erstellen.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das eingebettete Onboarding ausgewählt. Ihre verbundenen Konten werden über die Konto-Onboarding-Komponente, die direkt in Ihre Anwendung eingebettet ist, mit Ihrer Plattform verbunden.

### Endpoint hinzufügen, um eine Kontositzung zu erstellen

Fügen Sie einen Server-Endpoint hinzu, den Ihr Client aufrufen soll, um eine AccountSession zu erstellen. Mit der AccountSession können Sie die eingebetteten Connect.js-Komponenten verwenden.

### AccountSession erstellen

Erstellen Sie eine [AccountSession](https://docs.stripe.com/api/account_sessions.md), indem Sie die `v1/account_sessions`-API aufrufen.

### API-Zugriff auf Ihr verbundenes Konto delegieren

Geben Sie die ID des verbundenen Kontos an, in dessen Auftrag Sie handeln.

### Aktivierung der Komponente für das Konto-Onboarding

Aktivieren Sie die Komponente `account_onboarding` für die AccountSession.

### Client-Geheimnis zurückgeben

Lassen Sie Ihren Endpoint die Eigenschaft `client_secret` aus der AccountSession zurückgeben.

### Connect.js initialisieren

`loadConnectAndInitialize` gibt ein StripeConnect-Objekt zurück, das eine StripeConnectInstance erstellt. Übergeben Sie Ihren [veröffentlichbaren Schlüssel](https://docs.stripe.com/keys.md) und eine Funktion, die eine AccountSession erstellt und deren `client_secret` zurückgibt.

### Optional: Eingebettete Komponenten von Style Connect

Sie können das [Erscheinungsbild der Onboarding-Komponente anpassen](https://docs.stripe.com/connect/customize-connect-embedded-components.md), indem Sie eine `appearance`-Konfiguration übergeben, wenn Sie die StripeConnect-Instanz initialisieren. Standardmäßig erhalten die in Connect eingebetteten Komponenten die Schriftart des übergeordneten HTML-Elements. Sie können dies jedoch überschreiben, indem Sie das Farbschema Ihres Unternehmens übergeben.

### Die eingebettete Onboarding-Komponente von Connect einbinden

Fügen Sie die eingebettete Onboarding-Komponente von Connect hinzu. Nach der Initialisierung verwaltet die StripeConnectInstance den Kontext und verarbeitet Anfragen an Stripe unter Verwendung des Client-Geheimnisses und des veröffentlichbaren Schlüssels.

### Nutzer/innen weiterleiten, wenn das Onboarding abgeschlossen ist

Verwenden Sie Callback-Funktion `onExit`, um mit Ihren Nutzerinnen/Nutzern fortzufahren. Die Komponente ruft `onExit` auf, wenn Nutzer/innen das eingebettete Onboarding abgeschlossen haben.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das von Stripe gehostete Onboarding ausgewählt. Ihre Plattform leitet Ihre verbundenen Konten über einen [Konto-Link](https://docs.stripe.com/api/account_links.md) an eine von Stripe gehostete, Onboarding-Oberfläche mit Co-Branding weiter.

### Übersicht

Gemäß [Ihren Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das von Stripe gehostete Onboarding ausgewählt. Ihre Plattform leitet Ihre verbundenen Konten über einen [Konto-Link](https://docs.stripe.com/api/v2/core/account-links.md) an eine von Stripe gehostete Onboarding-Oberfläche mit Co-Branding weiter.

### Erstellen Sie einen Konto-Links-Endpoint

Fügen Sie einen Endpoint auf Ihrem Server hinzu, um einen Link zu erstellen.

### Rückgabe-URL angeben

Wenn Ihr verbundenes Konto das Onboarding abgeschlossen hat, wird es an die Rückgabe-URL weitergeleitet. Das bedeutet jedoch nicht, dass alle Informationen erfasst wurden oder dass es für das verbundene Konto keine ausstehenden Anforderungen gibt. Es bedeutet lediglich, dass der Ablauf ordnungsgemäß durchlaufen und beendet wurde.

### Aktualisierungs-URL angeben

Stripe leitet Ihr verbundenes Konto dann an die Aktualisierungs-URL weiter, wenn der Link abgelaufen ist, der Link bereits besucht wurde, Ihre Plattform nicht auf das verbundene Konto zugreifen kann oder das Konto abgelehnt wurde. Lassen Sie die Aktualisierungs-URL einen neuen Onboarding-Kontolink erstellen und leiten Sie Ihre Nutzer/innen an diesen weiter.

### Diesen Endpoint aufrufen, um einen Kontolink zu erstellen

Geben Sie die ID des verbundenen Kontos an.

### Nutzer/innen an die URL weiterleiten

Senden Sie Nutzer/innen zu Stripe, um das Onboarding durchzuführen. Nach Abschluss werden sie zu Ihrer App weitergeleitet.

### Rückkehr des verbundenen Kontos steuern

Zeigen Sie dem verbundenen Konto eine hilfreiche Seite, wenn es den von Stripe gehosteten Onboarding-Ablauf verlässt.

### Aktualisieren des Kontolinks steuern

Ihren Endpoint aufrufen, um den Konto-Link unter der Aktualisierungs-URL zu aktualisieren.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das API-Onboarding ausgewählt. Das Onboarding Ihrer verbundenen Konten erfolgt über einen von Ihnen erstellten Onboarding-Ablauf, der die Stripe-API aufruft. Ihre Plattform erfasst alle erforderlichen Verifizierungsinformationen.

### Endpoint zum Aktualisieren eines Kontos hinzufügen

Rufen Sie diesen Endpoint auf, um Stripe zeitgleich die Kontoinformationen zur Verfügung zu stellen, die Sie erfassen.

### Stripe Informationen zur Verfügung stellen

Geben Sie den Unternehmenstyp als Beispiel an.

### Den Endpoint aufrufen, um einen Kontolink zu erstellen

Geben Sie die ID des verbundenen Kontos an.

### Mit dem Onboarding-Ablauf fortfahren

Ermitteln Sie, welche [erforderlichen Informationen](https://docs.stripe.com/connect/custom/onboarding.md#establish-requirements) Sie erfassen müssen. Erstellen Sie einen Ablauf, über den Ihre verbundenen Konten die Eingabe vornehmen und an Stripe übergeben können.

### Stripe Node-Bibliothek installieren

Installieren Sie das Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### npm

Installieren Sie die Bibliothek:

```bash
npm install --save stripe@20.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Node-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0) herunter.

### Stripe-Ruby-Bibliothek installieren

Installieren Sie Stripe Ruby Gem und fordern Sie es in Ihrem Code an. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine Gemfile benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Terminal

Installieren Sie das Gem:

```bash
gem install stripe -v 18.1.0
```

#### Bundler

Fügen Sie diese Zeile zu Ihrer Gemfile hinzu:

```bash
gem 'stripe', '18.1.0'
```

#### GitHub

Laden Sie den Quellcode von Stripe Ruby Gem direkt [von GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0) herunter.

### Stripe Java-Bibliothek installieren

Fügen Sie Ihrem Build die Abhängigkeit hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `pom.xml`-Beispieldatei (für Maven) benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Maven

Fügen Sie Ihrem POM die folgende Abhängigkeit hinzu.

```bash
<dependency>\n<groupId>com.stripe</groupId>\n<artifactId>stripe-java</artifactId>\n<version>31.1.0</version>\n</dependency>
```

#### Gradle

Fügen Sie die Abhängigkeit zu Ihrer `build.gradle`-Datei hinzu.

```bash
implementation "com.stripe:stripe-java:31.1.0"
```

#### GitHub

Laden Sie die JAR-Datei direkt [von GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0) herunter.

### Stripe-Python-Paket installieren

Installieren Sie das Stripe-Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `requirements.txt`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### pip

Installieren Sie das Paket über pip:

```bash
pip3 install stripe==14.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Python-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0) herunter.

### Stripe PHP-Bibliothek installieren

Installieren Sie die Bibliothek mit Composer und initialisieren Sie sie mit Ihrem geheimen API-Schlüssel. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `composer.json`-Datei benötigen, laden Sie die Dateien über den Link im Code-Editor herunter.

#### Composer

Installieren Sie die Bibliothek:

```bash
composer require stripe/stripe-php:19.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-php-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0) herunter.

### Installieren Sie die Stripe Go-Bibliothek

Fügen Sie die Abhängigkeit zu Ihrem Build hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen und eine `go.mod`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Go

Initialisieren Sie mit Go-Modulen:

```bash
go get -u github.com/stripe/stripe-go/v85.0.0
```

#### GitHub

Laden Sie den Quellcode des Stripe-Go-Moduls direkt [von GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0) herunter.

### Stripe.net-Bibliothek installieren

Installieren Sie das Paket mit .NET oder NuGet. Wenn Sie aber komplett neu beginnen möchten, laden Sie die Dateien herunter, die eine konfigurierte `.csproj`-Datei enthalten.

#### dotnet

Installieren Sie die Bibliothek:

```bash
dotnet add package Stripe.net --version 50.1.0
```

#### NuGet

Installieren Sie die Bibliothek:

```bash
Install-Package Stripe.net -Version 50.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe.net-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0) herunter.

### Installieren Sie die Stripe Bibliothek

Installieren Sie die Pakete und importieren Sie sie in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

Installieren Sie die Bibliotheken und initialisieren Sie das Stripe SDK mit den richtigen Beta-Headern:

```bash
npm install --save stripe@20.1.0
```

### Geheimschlüssel festlegen

Fügen Sie Ihren Geheimschlüssel zu Ihrem Server hinzu.

### Umgebungsvariablen festlegen

Fügen Sie Ihren geheimen Schlüssel und Ihren veröffentlichbaren Schlüssel zu einer `.env`-Datei hinzu. Next.js lädt sie automatisch als [Umgebungsvariablen](https://nextjs.org/docs/basic-features/environment-variables) in Ihre Anwendung.

### Umgebungsvariablen festlegen

Fügen Sie Ihren Geheimschlüssel zu einer `.env`-Datei hinzu. Next.js lädt diesen automatisch als [Umgebungsvariablen](https://nextjs.org/docs/basic-features/environment-variables) in ihre Anwendung.

### Veröffentlichbaren Schlüssel festlegen

Fügen Sie Ihren veröffentlichbaren Schlüssel zu einer `.env`-Datei hinzu. React lädt sie automatisch als [Umgebungsvariablen](https://create-react-app.dev/docs/adding-custom-environment-variables/) in Ihre Anwendung.

### Connect.js einrichten

Importieren Sie das Modul [@stripe/connect-js](https://github.com/stripe/connect-js).

#### npm

Installieren Sie die Bibliothek:

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

#### GitHub

Laden Sie den Quellcode der @stripe/connect-js-Bibliothek direkt [von GitHub](https://github.com/stripe/connect-js) herunter.

### React Connect.js importieren

Importieren Sie das Modul [@stripe/react-connect-js](https://github.com/stripe/react-connect-js). React Connect.js ist ein schlanker Wrapper für eingebettete Connect-Komponenten, mit dem Sie jeder React-App eingebettete Komponenten hinzufügen können.

#### npm

Installieren Sie die Bibliothek:

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

#### GitHub

Laden Sie den Quellcode der @stripe/react-connect-js-Bibliothek direkt [von GitHub](https://github.com/stripe/react-connect-js) herunter.

### Ihr Plattform-Branding hinzufügen

Um das von Stripe gehostete Onboarding zu nutzen, gehen Sie zuerst zu Ihren [Onboarding-Einstellungen](https://dashboard.stripe.com/settings/connect/onboarding-interface) und passen Ihr Branding an. Sie müssen einen Firmennamen, ein Symbol und eine Markenfarbe festlegen.

### Übersicht

Ihre Connec-Integration ändert sich erheblich, je nachdem, wie Sie Ihre verbundenen Konten erstellen. Wir haben die Eigenschaften der verbundenen Konten basierend auf Ihren Entscheidungen bei der Einführung Ihres Plattformkontos in Connect angepasst. Die hier vorgenommenen Änderungen aktualisieren nicht Ihre Plattformeinstellungen und werden nicht im Stripe angezeigt.

Siehe [Entwerfen einer Integration](https://docs.stripe.com/connect/interactive-platform-guide.md), um mehr über diese Entscheidungen zu erfahren.

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Leiten Sie Ihre verbundenen Konten über einen Konto-Link zum von Stripe gehosteten Onboarding um.

#### Item 2

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Integrieren Sie die eingebettete Konto-Onboarding-Komponente in die Anwendung Ihrer Plattform.

#### Item 2

### Legen Sie fest, wie das Onboarding Ihrer verbundenen Konten zu Stripe abläuft

Ihre Wahl der Onboarding-Methode wirkt sich auf die Verfügbarkeit anderer Kontooptionen unten aus.

#### Item 1

Stellen Sie Verifizierungsinformationen für Ihre verbundenen Konten mithilfe der Stripe-API in einem von Ihnen selbst erstellten Onboarding-Ablauf bereit. Ihre Plattform ist für die Erfassung aktualisierter Informationen verantwortlich, wenn sich Anforderungen ändern oder fällig werden.

Stripe empfiehlt diese Option nur dann, wenn Sie sich voll und ganz über die Komplexität der Erstellung und Wartung eines API-Onboarding-Ablaufs im Klaren sind. Für ein benutzerdefiniertes Onboarding empfiehlt Stripe dringend ein eingebettetes Onboarding.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Geben Sie Ihren verbundenen Konten Zugriff auf das Stripe-Dashboard.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Geben Sie Ihren verbundenen Konten Zugriff auf das Express-Dashboard.

#### Item 2

### Wählen Sie aus, wo Ihre verbundenen Konten ihre Zahlungen und Kontodaten verwalten.

#### Item 1

Erstellen Sie eine Kontoverwaltungsschnittstelle für Ihre verbundenen Konten mithilfe der Stripe-API und der [eingebetteten Connect-Komponenten](https://docs.stripe.com/connect/get-started-connect-embedded-components.md).

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Sie erstellen Zahlungen direkt auf Ihren verbundenen Konten.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Destination Charges auf Ihrem Plattformkonto und übertragen Sie Geld auf Ihre verbundenen Konten. Fordern Sie die Funktion `transfers` für Ihre verbundenen Konten an.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Destination Charges auf Ihrem Plattformkonto und übertragen Sie Geld auf Ihre verbundenen Konten.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Zahlungen auf Ihrem Plattformkonto und teilen Sie die jeweiligen Beträge auf mehrere verbundene Konten auf. Fordern Sie die Funktion `transfers` für Ihre verbundenen Konten an.

#### Item 2

### Wählen Sie Ihren Zahlungstyp

#### Item 1

Erstellen Sie Zahlungen auf Ihrem Plattformkonto und teilen Sie die jeweiligen Beträge auf mehrere verbundene Konten auf.

#### Item 2

### Wählen Sie aus, wer die Gebühren zahlt

#### Item 1

Stripe zieht die Stripe-Gebühren von Ihren verbundenen Konten ein.

#### Item 2

### Wählen Sie aus, wer die Gebühren zahlt

#### Item 1

Stripe zieht die Stripe-Gebühren von Ihrer Plattform ein. Ihre Plattform kann Zahlungen über Plattformgebühren monetarisieren.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet nicht für negative Kontostände. Stripe ist dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet für negative Kontostände. Ihre Plattform ist auch dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

Bevor Sie Konten mit dieser Einrichtung erstellen, sollten Sie sorgfältig über die Verantwortung Ihrer Plattform für Verbindlichkeiten aus Negativsalden nachdenken und diese anerkennen.

#### Item 2

### Wählen Sie aus, wer für negative Kontostände haftet

#### Item 1

Ihre Plattform haftet für negative Kontostände. Stripe ist dafür verantwortlich, aktualisierte Informationen zu erfassen, wenn Anforderungen fällig sind oder sich ändern.

Bevor Sie Konten mit dieser Einrichtung erstellen, sollten Sie sorgfältig über die Verantwortung Ihrer Plattform für Verbindlichkeiten aus Negativsalden nachdenken und diese anerkennen.

#### Item 2

### Stripe Node-Bibliothek installieren

Installieren Sie das Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### npm

Installieren Sie die Bibliothek:

```bash
npm install --save stripe@20.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Node-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0) herunter.

### Stripe-Ruby-Bibliothek installieren

Installieren Sie Stripe Ruby Gem und fordern Sie es in Ihrem Code an. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine Gemfile benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Terminal

Installieren Sie das Gem:

```bash
gem install stripe -v 18.1.0
```

#### Bundler

Fügen Sie diese Zeile zu Ihrer Gemfile hinzu:

```bash
gem 'stripe', '18.1.0'
```

#### GitHub

Laden Sie den Quellcode von Stripe Ruby Gem direkt [von GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0) herunter.

### Stripe Java-Bibliothek installieren

Fügen Sie Ihrem Build die Abhängigkeit hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `pom.xml`-Beispieldatei (für Maven) benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Maven

Fügen Sie Ihrem POM die folgende Abhängigkeit hinzu.

```bash
<dependency>\n<groupId>com.stripe</groupId>\n<artifactId>stripe-java</artifactId>\n<version>31.1.0</version>\n</dependency>
```

#### Gradle

Fügen Sie die Abhängigkeit zu Ihrer `build.gradle`-Datei hinzu.

```bash
implementation "com.stripe:stripe-java:31.1.0"
```

#### GitHub

Laden Sie die JAR-Datei direkt [von GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0) herunter.

### Stripe-Python-Paket installieren

Installieren Sie das Stripe-Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `requirements.txt`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### pip

Installieren Sie das Paket über pip:

```bash
pip3 install stripe==14.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-Python-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0) herunter.

### Stripe PHP-Bibliothek installieren

Installieren Sie die Bibliothek mit Composer und initialisieren Sie sie mit Ihrem geheimen API-Schlüssel. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `composer.json`-Datei benötigen, laden Sie die Dateien über den Link im Code-Editor herunter.

#### Composer

Installieren Sie die Bibliothek:

```bash
composer require stripe/stripe-php:19.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe-php-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0) herunter.

### Installieren Sie die Stripe Go-Bibliothek

Fügen Sie die Abhängigkeit zu Ihrem Build hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen und eine `go.mod`-Datei benötigen, laden Sie die Projektdateien über den Link im Code-Editor herunter.

#### Go

Initialisieren Sie mit Go-Modulen:

```bash
go get -u github.com/stripe/stripe-go/v85.0.0
```

#### GitHub

Laden Sie den Quellcode des Stripe-Go-Moduls direkt [von GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0) herunter.

### Stripe.net-Bibliothek installieren

Installieren Sie das Paket mit .NET oder NuGet. Wenn Sie aber komplett neu beginnen möchten, laden Sie die Dateien herunter, die eine konfigurierte `.csproj`-Datei enthalten.

#### dotnet

Installieren Sie die Bibliothek:

```bash
dotnet add package Stripe.net --version 50.1.0
```

#### NuGet

Installieren Sie die Bibliothek:

```bash
Install-Package Stripe.net -Version 50.1.0
```

#### GitHub

Laden Sie den Quellcode der Stripe.net-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0) herunter.

### Installieren Sie die Stripe Bibliothek

Installieren Sie die Pakete und importieren Sie sie in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

Installieren Sie die Bibliotheken und initialisieren Sie das Stripe SDK mit den richtigen Beta-Headern:

```bash
npm install --save stripe@20.1.0
```

### Geheimschlüssel festlegen

Fügen Sie Ihren Geheimschlüssel zu Ihrem Server hinzu.

### Umgebungsvariablen festlegen

Fügen Sie Ihren geheimen Schlüssel und Ihren veröffentlichbaren Schlüssel zu einer `.env`-Datei hinzu. Next.js lädt sie automatisch als [Umgebungsvariablen](https://nextjs.org/docs/basic-features/environment-variables) in Ihre Anwendung.

### Umgebungsvariablen festlegen

Fügen Sie Ihren Geheimschlüssel zu einer `.env`-Datei hinzu. Next.js lädt diesen automatisch als [Umgebungsvariablen](https://nextjs.org/docs/basic-features/environment-variables) in ihre Anwendung.

### Veröffentlichbaren Schlüssel festlegen

Fügen Sie Ihren veröffentlichbaren Schlüssel zu einer `.env`-Datei hinzu. React lädt sie automatisch als [Umgebungsvariablen](https://create-react-app.dev/docs/adding-custom-environment-variables/) in Ihre Anwendung.

### Connect.js einrichten

Importieren Sie das Modul [@stripe/connect-js](https://github.com/stripe/connect-js).

#### npm

Installieren Sie die Bibliothek:

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

#### GitHub

Laden Sie den Quellcode der @stripe/connect-js-Bibliothek direkt [von GitHub](https://github.com/stripe/connect-js) herunter.

### React Connect.js importieren

Importieren Sie das Modul [@stripe/react-connect-js](https://github.com/stripe/react-connect-js). React Connect.js ist ein schlanker Wrapper für eingebettete Connect-Komponenten, mit dem Sie jeder React-App eingebettete Komponenten hinzufügen können.

#### npm

Installieren Sie die Bibliothek:

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

#### GitHub

Laden Sie den Quellcode der @stripe/react-connect-js-Bibliothek direkt [von GitHub](https://github.com/stripe/react-connect-js) herunter.

### Ihr Plattform-Branding hinzufügen

Um das von Stripe gehostete Onboarding zu nutzen, gehen Sie zuerst zu Ihren [Onboarding-Einstellungen](https://dashboard.stripe.com/settings/connect/onboarding-interface) und passen Ihr Branding an. Sie müssen einen Firmennamen, ein Symbol und eine Markenfarbe festlegen.

### Fügen Sie einen Endpoint hinzu, um ein verbundenes Konto zu erstellen.

Richten Sie auf Ihrem Server einen Endpoint ein, den Ihr Client anrufen kann, um die Erstellung eines verbundenen Kontos zu bearbeiten.

### Verbundenes Konto erstellen

Erstellen Sie ein verbundenes Konto, indem Sie die Stripe API aufrufen. Wir haben die verwendeten Attribute basierend auf den oben ausgewählten Einstellungen konfiguriert. Sie können Verifizierungsinformationen, das Geschäftsprofil des Nutzers/der Nutzerin und andere Felder im [Konto](https://docs.stripe.com/api/accounts/create.md) vorab ausfüllen, wenn Ihre Plattform sie bereits erfasst hat.

### Verbundenes Konto erstellen

Erstellen Sie ein verbundenes Konto, indem Sie die Stripe API aufrufen. Wir haben die verwendeten Attribute basierend auf den oben ausgewählten Einstellungen konfiguriert. Sie können Verifizierungsinformationen, das Unternehmensprofil der Nutzerin/des Nutzers sowie weitere Felder im [Konto](https://docs.stripe.com/api/v2/core/accounts/create.md) vorab ausfüllen, wenn Ihre Plattform diese Daten bereits erfasst hat.

### Geben Sie das Land des Kontos an

Wenn Ihre Konten kein von Stripe gehostetes Dashboard verwenden, müssen Sie das Land des Kontos im Voraus angeben.

### Geben Sie das Land des Kontos an

Sie müssen das Feld `identity.country` des Kontos im Voraus angeben.

### Rufen Sie den Endpoint auf, um ein verbundenes Konto zu erstellen.

Rufen Sie den Endpoint auf, den Sie oben hinzugefügt haben, um ein verbundenes Konto zu erstellen.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das eingebettete Onboarding ausgewählt. Ihre verbundenen Konten werden über die Konto-Onboarding-Komponente, die direkt in Ihre Anwendung eingebettet ist, mit Ihrer Plattform verbunden.

### Endpoint hinzufügen, um eine Kontositzung zu erstellen

Fügen Sie einen Server-Endpoint hinzu, den Ihr Client aufrufen soll, um eine AccountSession zu erstellen. Mit der AccountSession können Sie die eingebetteten Connect.js-Komponenten verwenden.

### AccountSession erstellen

Erstellen Sie eine [AccountSession](https://docs.stripe.com/api/account_sessions.md), indem Sie die `v1/account_sessions`-API aufrufen.

### API-Zugriff auf Ihr verbundenes Konto delegieren

Geben Sie die ID des verbundenen Kontos an, in dessen Auftrag Sie handeln.

### Aktivierung der Komponente für das Konto-Onboarding

Aktivieren Sie die Komponente `account_onboarding` für die AccountSession.

### Client-Geheimnis zurückgeben

Lassen Sie Ihren Endpoint die Eigenschaft `client_secret` aus der AccountSession zurückgeben.

### Connect.js initialisieren

`loadConnectAndInitialize` gibt ein StripeConnect-Objekt zurück, das eine StripeConnectInstance erstellt. Übergeben Sie Ihren [veröffentlichbaren Schlüssel](https://docs.stripe.com/keys.md) und eine Funktion, die eine AccountSession erstellt und deren `client_secret` zurückgibt.

### Optional: Eingebettete Komponenten von Style Connect

Sie können das [Erscheinungsbild der Onboarding-Komponente anpassen](https://docs.stripe.com/connect/customize-connect-embedded-components.md), indem Sie eine `appearance`-Konfiguration übergeben, wenn Sie die StripeConnect-Instanz initialisieren. Standardmäßig erhalten die in Connect eingebetteten Komponenten die Schriftart des übergeordneten HTML-Elements. Sie können dies jedoch überschreiben, indem Sie das Farbschema Ihres Unternehmens übergeben.

### Die eingebettete Onboarding-Komponente von Connect einbinden

Fügen Sie die eingebettete Onboarding-Komponente von Connect hinzu. Nach der Initialisierung verwaltet die StripeConnectInstance den Kontext und verarbeitet Anfragen an Stripe unter Verwendung des Client-Geheimnisses und des veröffentlichbaren Schlüssels.

### Nutzer/innen weiterleiten, wenn das Onboarding abgeschlossen ist

Verwenden Sie Callback-Funktion `onExit`, um mit Ihren Nutzerinnen/Nutzern fortzufahren. Die Komponente ruft `onExit` auf, wenn Nutzer/innen das eingebettete Onboarding abgeschlossen haben.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das von Stripe gehostete Onboarding ausgewählt. Ihre Plattform leitet Ihre verbundenen Konten über einen [Konto-Link](https://docs.stripe.com/api/account_links.md) an eine von Stripe gehostete, Onboarding-Oberfläche mit Co-Branding weiter.

### Übersicht

Gemäß [Ihren Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das von Stripe gehostete Onboarding ausgewählt. Ihre Plattform leitet Ihre verbundenen Konten über einen [Konto-Link](https://docs.stripe.com/api/v2/core/account-links.md) an eine von Stripe gehostete Onboarding-Oberfläche mit Co-Branding weiter.

### Erstellen Sie einen Konto-Links-Endpoint

Fügen Sie einen Endpoint auf Ihrem Server hinzu, um einen Link zu erstellen.

### Rückgabe-URL angeben

Wenn Ihr verbundenes Konto das Onboarding abgeschlossen hat, wird es an die Rückgabe-URL weitergeleitet. Das bedeutet jedoch nicht, dass alle Informationen erfasst wurden oder dass es für das verbundene Konto keine ausstehenden Anforderungen gibt. Es bedeutet lediglich, dass der Ablauf ordnungsgemäß durchlaufen und beendet wurde.

### Aktualisierungs-URL angeben

Stripe leitet Ihr verbundenes Konto dann an die Aktualisierungs-URL weiter, wenn der Link abgelaufen ist, der Link bereits besucht wurde, Ihre Plattform nicht auf das verbundene Konto zugreifen kann oder das Konto abgelehnt wurde. Lassen Sie die Aktualisierungs-URL einen neuen Onboarding-Kontolink erstellen und leiten Sie Ihre Nutzer/innen an diesen weiter.

### Diesen Endpoint aufrufen, um einen Kontolink zu erstellen

Geben Sie die ID des verbundenen Kontos an.

### Nutzer/innen an die URL weiterleiten

Senden Sie Nutzer/innen zu Stripe, um das Onboarding durchzuführen. Nach Abschluss werden sie zu Ihrer App weitergeleitet.

### Rückkehr des verbundenen Kontos steuern

Zeigen Sie dem verbundenen Konto eine hilfreiche Seite, wenn es den von Stripe gehosteten Onboarding-Ablauf verlässt.

### Aktualisieren des Kontolinks steuern

Ihren Endpoint aufrufen, um den Konto-Link unter der Aktualisierungs-URL zu aktualisieren.

### Übersicht

Gemäß [Ihrer Einstellungen](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface) haben Sie das API-Onboarding ausgewählt. Das Onboarding Ihrer verbundenen Konten erfolgt über einen von Ihnen erstellten Onboarding-Ablauf, der die Stripe-API aufruft. Ihre Plattform erfasst alle erforderlichen Verifizierungsinformationen.

### Endpoint zum Aktualisieren eines Kontos hinzufügen

Rufen Sie diesen Endpoint auf, um Stripe zeitgleich die Kontoinformationen zur Verfügung zu stellen, die Sie erfassen.

### Stripe Informationen zur Verfügung stellen

Geben Sie den Unternehmenstyp als Beispiel an.

### Den Endpoint aufrufen, um einen Kontolink zu erstellen

Geben Sie die ID des verbundenen Kontos an.

### Mit dem Onboarding-Ablauf fortfahren

Ermitteln Sie, welche [erforderlichen Informationen](https://docs.stripe.com/connect/custom/onboarding.md#establish-requirements) Sie erfassen müssen. Erstellen Sie einen Ablauf, über den Ihre verbundenen Konten die Eingabe vornehmen und an Stripe übergeben können.

### Zahlungen akzeptieren

Nachdem Sie das Onboarding für ein verbundenes Konto abgeschlossen haben, können Sie [Direct Charges](https://docs.stripe.com/connect/direct-charges.md) erstellen.

### Zahlungen akzeptieren

Nachdem Sie das Onboarding für ein verbundenes Konto abgeschlossen haben, können Sie [Destination Charges](https://docs.stripe.com/connect/destination-charges.md) erstellen.

### Zahlungen akzeptieren

Nachdem Sie das Onboarding für ein verbundenes Konto abgeschlossen haben, können [Sie separate Zahlungen und Überweisungen erstellen](https://docs.stripe.com/connect/separate-charges-and-transfers.md).

### Mit der Erstellung des API-Onboardings fortfahren

Mit der Dokumentation für die [erforderlichen Verifizierungsinformationen](https://docs.stripe.com/connect/required-verification-information.md) erstellen Sie für Ihre verbundenen Konten eine Möglichkeit, um das Onboarding abzuschließen. [Erstellen Sie anschließend Direct Charges](https://docs.stripe.com/connect/direct-charges.md)

### Mit der Erstellung des API-Onboardings fortfahren

Mit der Dokumentation für die [erforderlichen Verifizierungsinformationen](https://docs.stripe.com/connect/required-verification-information.md) erstellen Sie für Ihre verbundenen Konten eine Möglichkeit, um das Onboarding abzuschließen. [Erstellen Sie anschließend Destination Charges](https://docs.stripe.com/connect/destination-charges.md)

### Mit der Erstellung des API-Onboardings fortfahren

Mit der Dokumentation für die [erforderlichen Verifizierungsinformationen](https://docs.stripe.com/connect/required-verification-information.md) erstellen Sie für Ihre verbundenen Konten eine Möglichkeit, um das Onboarding abzuschließen. Anschließend [erstellen Sie separate Zahlungen und Überweisungen](https://docs.stripe.com/connect/separate-charges-and-transfers.md).