# Créer une intégration Connect

# Inscrire des comptes à votre plateforme Connect

Créez un compte connecté et collectez ses informations pour activer les paiements. Nous vous recommandons de sélectionner les propriétés avant de télécharger un exemple d’application, car votre intégration changera de manière significative.

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)
### Installer la bibliothèque Stripe Node

Installez le package et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-node directement [depuis GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0).

### Installer la bibliothèque Stripe Ruby

Installez la gem Ruby de Stripe et exigez-la dans votre code. Si vous partez de zéro et avez besoin d’un Gemfile, téléchargez les fichiers du projet à l’aide du lien dans l’éditeur de code.

#### Terminal

Installez le fichier GEM&nbsp;:

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

#### Bundler

Ajoutez cette ligne à votre fichier Gemfile&nbsp;:

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

#### GitHub

Télécharger le code source Stripe-ruby gem directement [depuis GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0)

### Installer la bibliothèque Java de Stripe

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un exemple de fichier `pom.xml` (pour Maven), vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Maven

Ajoutez la dépendance suivante à votre modèle d’objet de projet POM.

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

#### Gradle

Ajoutez la dépendance à votre fichier `build.gradle`.

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

#### GitHub

Télécharger le JAR directement [depuis GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0)

### Installer le package Python de Stripe

Installez le package Stripe et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `requirements.txt`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### pip

Installez le package via pip&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque stripe-python directement [depuis GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0).

### Installer la bibliothèque PHP de Stripe

Installez la bibliothèque avec Composer et initialisez-la avec votre clé API secrète. Si vous partez de zéro et avez besoin d’un fichier `composer.json`, vous pouvez également télécharger les fichiers à l’aide du lien de téléchargement dans l’éditeur de code.

#### Composer

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-php directement [depuis GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0).

### Installer la bibliothèque Stripe Go

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un fichier `go.mod`, téléchargez les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Go

Assurez-vous d’effectuer l’initialisation avec les modules Go&nbsp;:

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

#### GitHub

Téléchargez le code source du module stripe-go directement [depuis GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0).

### Installer la bibliothèque Stripe.net

Installez le package avec .NET ou NuGet. Si vous partez de zéro, vous pouvez également télécharger les fichiers qui comprennent un fichier `.csproj` configuré.

#### dotnet

Installez la bibliothèque&nbsp;:

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

#### NuGet

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe.net directement [depuis GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0).

### Installer la bibliothèque Stripe

Installez les packages et importez-les dans votre code. Si vous partez de zéro et qu’il vous faut un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

Installez les bibliothèques, puis initialisez le SDK Stripe avec les en-têtes bêta appropriés&nbsp;:

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

### Présentation

Votre intégration à Connect change de manière significative en fonction de la façon dont vous créez vos comptes connectés. Nous avons personnalisé les propriétés du compte connecté en fonction de vos choix lors de l’inscription de votre compte de plateforme à Connect. Les changements effectués ici ne mettent pas à jour les paramètres de votre plateforme et ne sont pas reflétés dans le Dashboard Stripe.

Consultez la page [Concevoir une intégration](https://docs.stripe.com/connect/interactive-platform-guide.md) pour en savoir plus sur ces choix.

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Redirigez vos comptes connectés vers l’inscription hébergée par Stripe à l’aide d’un lien de compte.

#### Item 2

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Intégrez le composant intégré Account Onboarding dans l’application de votre plateforme.

#### Item 2

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Fournissez des informations de vérification pour vos comptes connectés à l’aide de l’API Stripe dans un flux d’inscription que vous élaborez vous-même. Votre plateforme est responsable de la collecte des informations mises à jour lorsque les exigences évoluent ou doivent être satisfaites.

Stripe ne recommande pas cette option à moins que vous ne soyez pleinement conscient dans la complexité opérationnelle requise pour développer et gérer un flux d’inscription des utilisateurs via l’API. Pour une inscription des utilisateurs personnalisée, Stripe recommande fortement l’inscription intégré.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Donnez à vos comptes connectés l’accès au Dashboard Stripe.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Donnez à vos comptes connectés l’accès au Dashboard Express.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Créez une interface de gestion de comptes pour vos comptes connectés à l’aide de l’API Stripe et des [composants intégrés à Connect](https://docs.stripe.com/connect/get-started-connect-embedded-components.md).

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements directement sur vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements indirects sur votre compte de plateforme en transférant de l’argent vers vos comptes connectés. Demandez la fonctionnalité `transfers` pour vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements indirects sur votre compte de plateforme en transférant de l’argent vers vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements sur votre compte de plateforme et répartissez chaque montant entre plusieurs comptes connectés. Demandez la fonctionnalité `transfers` pour vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements sur votre compte de plateforme et répartissez chaque montant entre plusieurs comptes connectés.

#### Item 2

### Déterminer qui paie les frais

#### Item 1

Stripe prélève des frais à vos comptes connectés.

#### Item 2

### Déterminer qui paie les frais

#### Item 1

Stripe prélève des frais à votre plateforme. Votre plateforme peut monétiser les paiements en utilisant les commissions de plateforme.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plateforme n’est pas responsable des soldes négatifs des comptes. Stripe est responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plate-forme est responsable des soldes négatifs des comptes. Votre plateforme est également responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

Avant de créer des comptes avec cette configuration, reconnaissez et considérez avec circonspection les responsabilités de votre plateforme en matière de solde négatif.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plateforme est responsable des soldes négatifs des comptes. Stripe est responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

Avant de créer des comptes avec cette configuration, reconnaissez et considérez avec circonspection les responsabilités de votre plateforme en matière de solde négatif.

#### Item 2

### Ajouter un endpoint pour mettre en place un compte connecté

Définissez sur votre serveur un endpoint que votre client pourra appeler pour gérer la création d’un compte connecté.

### Créer un compte connecté

Créez un compte connecté en appelant l’API Stripe. Nous avons configuré les attributs utilisés en fonction des préférences que vous avez sélectionnées ci-dessus. Vous pouvez préremplir les informations de vérification, le profil d’entreprise de l’utilisateur et d’autres champs du [compte](https://docs.stripe.com/api/accounts/create.md) si votre plateforme les a déjà collectés.

### Créer un compte connecté

Créez un compte connecté en utilisant l’API Stripe. Nous avons configuré les attributs utilisés en fonction des préférences que vous avez sélectionnées ci-dessus. Vous pouvez préremplir les informations de vérification, le profil d’entreprise de l’utilisateur et d’autres champs sur le [compte](https://docs.stripe.com/api/v2/core/accounts/create.md) si votre plateforme les a déjà collectés.

### Indiquer le pays du compte

Lorsque vos comptes n’utilisent pas un Dashboard hébergé par Stripe, vous devez spécifier le pays du compte en amont.

### Indiquer le pays du compte

Vous devez spécifier à l’avance l’`identity.country` du compte.

### Appeler l’endpoint pour créer un compte connecté

Appelez l’endpoint que vous avez ajouté ci-dessus pour créer un compte connecté.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’inscription des utilisateurs intégrée. Vos comptes connectés sont intégrés à votre plateforme par le biais du composant Account Onboarding, qui est directement intégré dans votre application.

### Ajouter un endpoint pour créer une session de compte

Ajoutez un endpoint de serveur que votre client pourra appeler pour créer une AccountSession. Une AccountSession vous permet d’utiliser des composants intégrés Connect.js.

### Créer une AccountSession

Créez une [AccountSession](https://docs.stripe.com/api/account_sessions.md) en appelant l’API `v1/account_sessions`.

### Déléguer l’accès API à votre compte connecté

Précisez l’ID du compte connecté au nom duquel vous agissez.

### Activer le composant d’inscription de compte

Activez le composant `account_onboarding` pour l’AccountSession.

### Renvoyer la clé secrète du client

Demandez à votre endpoint de renvoyer la propriété `client_secret` de l’AccountSession.

### Initialiser Connect.js

`loadConnectAndInitialize` renvoie un objet StripeConnect, qui crée une instance StripeConnectInstance. Transmettez votre [clé publiable](https://docs.stripe.com/keys.md) ainsi qu’une fonction qui crée une AccountSession et renvoie son `client_secret`.

### Facultatif&nbsp;: styliser les composants intégrés Connect

Vous pouvez [personnaliser l’apparence du composant d’inscription](https://docs.stripe.com/connect/customize-connect-embedded-components.md) en transmettant une configuration `appearance` lorsque vous initialisez l’instance StripeConnect. Par défaut, les composants intégrés Connect héritent de la famille de polices de l’élément HTML parent, mais vous pouvez la remplacer en transmettant la palette de couleurs de votre entreprise.

### Inclure le composant d’inscription intégré de Connect

Ajoutez le composant d’inscription intégré de Connect. Après l’initialisation, StripeConnectInstance gère le contexte et traite les requêtes à Stripe à l’aide de la clé secrète du client et de la clé publique.

### Rediriger l’utilisateur une fois l’inscription terminée

Utilisez le rappel `onExit` pour faire avancer votre utilisateur. Le composant appelle `onExit` lorsque l’utilisateur a effectué l’inscription intégrée.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez sélectionné l’inscription hébergée par Stripe. Votre plateforme redirige vos comptes connectés vers une interface d’inscription comarquée et hébergée par Stripe à l’aide d’un [lien de compte](https://docs.stripe.com/api/account_links.md).

### Présentation

Selon votre [sélection de préférence](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’onboarding hébergé par Stripe. Votre plateforme redirige vos comptes connectés vers une interface d’onboarding co-brandée hébergée par Stripe en utilisant un [Compte Link](https://docs.stripe.com/api/v2/core/account-links.md).

### Créez un endpoint lien de compte

Ajoutez un endpoint sur votre serveur pour créer un lien de compte.

### Indiquez une URL de redirection

Une fois que votre compte connecté a terminé le flux d’inscription, il est redirigé vers l’URL de redirection. Cela ne signifie pas que toutes les informations ont été collectées ni que le compte connecté a satisfait toutes ses exigences, mais simplement qu’il est entré dans le flux et en est sorti sans aucun souci particulier.

### Indiquer une URL d’actualisation

Stripe redirige votre compte connecté vers l’URL d’actualisation lorsque le lien a expiré, qu’il a déjà été utilisé, que votre plateforme ne peut pas accéder au compte connecté ou que le compte est refusé. Faites en sorte que l’URL d’actualisation crée un nouveau lien de compte d’inscription et y redirige votre utilisateur.

### Appeler l’endpoint pour créer un lien de compte

Fournissez l’ID du compte connecté.

### Rediriger l’utilisateur vers l’URL

Redirigez l’utilisateur vers Stripe pour qu’il finalise l’inscription. Une fois l’inscription terminée, il est redirigé vers votre application.

### Gérer le retour du compte connecté

Affichez une page utile au compte connecté lorsqu’il quitte le flux d’inscription hébergé par Stripe.

### Gérer l’actualisation du lien de compte

Appelez votre endpoint pour actualiser le lien de compte au niveau de l’URL d’actualisation.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’inscription des utilisateurs via l’API. Vos comptes connectés s’inscrivent sur votre plateforme par le biais d’un flux d’inscription que vous créez et qui appelle l’API de Stripe. Votre plateforme collecte toutes les informations de vérification requises.

### Ajouter un endpoint pour mettre à jour un compte

Appelez ce endpoint pour fournir les informations du compte à Stripe lorsque vous les collectez.

### Fournir des informations à Stripe

Indiquez le type d’entreprise comme exemple de données.

### Appeler le endpoint pour mettre à jour un compte

Fournissez l’ID du compte connecté.

### Faire avancer le flux d’inscription

Déterminez les [informations requises](https://docs.stripe.com/connect/custom/onboarding.md#establish-requirements) que vous devez recueillir. Créez un flux permettant à vos comptes connectés de les saisir et de les transmettre à Stripe.

### Installer la bibliothèque Stripe Node

Installez le package et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-node directement [depuis GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0).

### Installer la bibliothèque Stripe Ruby

Installez la gem Ruby de Stripe et exigez-la dans votre code. Si vous partez de zéro et avez besoin d’un Gemfile, téléchargez les fichiers du projet à l’aide du lien dans l’éditeur de code.

#### Terminal

Installez le fichier GEM&nbsp;:

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

#### Bundler

Ajoutez cette ligne à votre fichier Gemfile&nbsp;:

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

#### GitHub

Télécharger le code source Stripe-ruby gem directement [depuis GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0)

### Installer la bibliothèque Java de Stripe

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un exemple de fichier `pom.xml` (pour Maven), vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Maven

Ajoutez la dépendance suivante à votre modèle d’objet de projet POM.

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

#### Gradle

Ajoutez la dépendance à votre fichier `build.gradle`.

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

#### GitHub

Télécharger le JAR directement [depuis GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0)

### Installer le package Python de Stripe

Installez le package Stripe et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `requirements.txt`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### pip

Installez le package via pip&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque stripe-python directement [depuis GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0).

### Installer la bibliothèque PHP de Stripe

Installez la bibliothèque avec Composer et initialisez-la avec votre clé API secrète. Si vous partez de zéro et avez besoin d’un fichier `composer.json`, vous pouvez également télécharger les fichiers à l’aide du lien de téléchargement dans l’éditeur de code.

#### Composer

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-php directement [depuis GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0).

### Installer la bibliothèque Stripe Go

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un fichier `go.mod`, téléchargez les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Go

Assurez-vous d’effectuer l’initialisation avec les modules Go&nbsp;:

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

#### GitHub

Téléchargez le code source du module stripe-go directement [depuis GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0).

### Installer la bibliothèque Stripe.net

Installez le package avec .NET ou NuGet. Si vous partez de zéro, vous pouvez également télécharger les fichiers qui comprennent un fichier `.csproj` configuré.

#### dotnet

Installez la bibliothèque&nbsp;:

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

#### NuGet

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe.net directement [depuis GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0).

### Installer la bibliothèque Stripe

Installez les packages et importez-les dans votre code. Si vous partez de zéro et qu’il vous faut un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

Installez les bibliothèques, puis initialisez le SDK Stripe avec les en-têtes bêta appropriés&nbsp;:

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

### Configurez votre clé secrète

Ajoutez votre clé secrète à votre serveur.

### Configurer les variables d’environnement

Ajoutez vos clés secrètes et publiques à un fichier `.env`. Next.js les charge automatiquement dans votre application en tant que [variable d’environnement](https://nextjs.org/docs/basic-features/environment-variables).

### Configurer les variables d’environnement

Ajoutez votre clé secrète à un fichier `.env`. Next.js la charge automatiquement dans votre application en tant que [variable d’environnement](https://nextjs.org/docs/basic-features/environment-variables).

### Configurez votre clé publique

Ajoutez votre clé publique à un fichier `.env`. React la charge automatiquement dans votre application en tant que [variable d’environnement](https://create-react-app.dev/docs/adding-custom-environment-variables/).

### Configurer Connect.js

Importez le module [@stripe/connect-js](https://github.com/stripe/connect-js).

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque @stripe/connect-js directement [depuis GitHub](https://github.com/stripe/connect-js).

### Importer React Connect.js

Importez le module [@stripe/react-connect-js](https://github.com/stripe/react-connect-js). React Connect.js est un wrapper léger autour des composants intégrés Connect qui vous permet d’ajouter des composants intégrés à n’importe quelle application React.

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque @stripe/react-connect-js directement [depuis GitHub](https://github.com/stripe/react-connect-js).

### Ajouter l’image de marque de la plateforme

Pour utiliser l’inscription hébergée par Stripe, accédez d’abord à vos [paramètres d’inscription](https://dashboard.stripe.com/settings/connect/onboarding-interface) et personnalisez votre image de marque. Vous devez définir un nom d’entreprise, une icône et une couleur de marque.

### Présentation

Votre intégration à Connect change de manière significative en fonction de la façon dont vous créez vos comptes connectés. Nous avons personnalisé les propriétés du compte connecté en fonction de vos choix lors de l’inscription de votre compte de plateforme à Connect. Les changements effectués ici ne mettent pas à jour les paramètres de votre plateforme et ne sont pas reflétés dans le Dashboard Stripe.

Consultez la page [Concevoir une intégration](https://docs.stripe.com/connect/interactive-platform-guide.md) pour en savoir plus sur ces choix.

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Redirigez vos comptes connectés vers l’inscription hébergée par Stripe à l’aide d’un lien de compte.

#### Item 2

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Intégrez le composant intégré Account Onboarding dans l’application de votre plateforme.

#### Item 2

### Choisir comment vos comptes connectés s’inscrivent à Stripe

Le choix de la méthode d’inscription des utilisateurs a une incidence sur la disponibilité des autres options de compte ci-dessous.

#### Item 1

Fournissez des informations de vérification pour vos comptes connectés à l’aide de l’API Stripe dans un flux d’inscription que vous élaborez vous-même. Votre plateforme est responsable de la collecte des informations mises à jour lorsque les exigences évoluent ou doivent être satisfaites.

Stripe ne recommande pas cette option à moins que vous ne soyez pleinement conscient dans la complexité opérationnelle requise pour développer et gérer un flux d’inscription des utilisateurs via l’API. Pour une inscription des utilisateurs personnalisée, Stripe recommande fortement l’inscription intégré.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Donnez à vos comptes connectés l’accès au Dashboard Stripe.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Donnez à vos comptes connectés l’accès au Dashboard Express.

#### Item 2

### Choisir où vos comptes connectés gèrent leurs paiements et informations de compte

#### Item 1

Créez une interface de gestion de comptes pour vos comptes connectés à l’aide de l’API Stripe et des [composants intégrés à Connect](https://docs.stripe.com/connect/get-started-connect-embedded-components.md).

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements directement sur vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements indirects sur votre compte de plateforme en transférant de l’argent vers vos comptes connectés. Demandez la fonctionnalité `transfers` pour vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements indirects sur votre compte de plateforme en transférant de l’argent vers vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements sur votre compte de plateforme et répartissez chaque montant entre plusieurs comptes connectés. Demandez la fonctionnalité `transfers` pour vos comptes connectés.

#### Item 2

### Choisir votre type de paiement

#### Item 1

Créez des paiements sur votre compte de plateforme et répartissez chaque montant entre plusieurs comptes connectés.

#### Item 2

### Déterminer qui paie les frais

#### Item 1

Stripe prélève des frais à vos comptes connectés.

#### Item 2

### Déterminer qui paie les frais

#### Item 1

Stripe prélève des frais à votre plateforme. Votre plateforme peut monétiser les paiements en utilisant les commissions de plateforme.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plateforme n’est pas responsable des soldes négatifs des comptes. Stripe est responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plate-forme est responsable des soldes négatifs des comptes. Votre plateforme est également responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

Avant de créer des comptes avec cette configuration, reconnaissez et considérez avec circonspection les responsabilités de votre plateforme en matière de solde négatif.

#### Item 2

### Déterminer qui est responsable en cas de solde négatif

#### Item 1

Votre plateforme est responsable des soldes négatifs des comptes. Stripe est responsable de la collecte des informations à jour lorsque les exigences doivent être satisfaites ou évoluent.

Avant de créer des comptes avec cette configuration, reconnaissez et considérez avec circonspection les responsabilités de votre plateforme en matière de solde négatif.

#### Item 2

### Installer la bibliothèque Stripe Node

Installez le package et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-node directement [depuis GitHub](https://github.com/stripe/stripe-node/releases/tag/v20.1.0).

### Installer la bibliothèque Stripe Ruby

Installez la gem Ruby de Stripe et exigez-la dans votre code. Si vous partez de zéro et avez besoin d’un Gemfile, téléchargez les fichiers du projet à l’aide du lien dans l’éditeur de code.

#### Terminal

Installez le fichier GEM&nbsp;:

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

#### Bundler

Ajoutez cette ligne à votre fichier Gemfile&nbsp;:

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

#### GitHub

Télécharger le code source Stripe-ruby gem directement [depuis GitHub](https://github.com/stripe/stripe-ruby/releases/tag/v18.1.0)

### Installer la bibliothèque Java de Stripe

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un exemple de fichier `pom.xml` (pour Maven), vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Maven

Ajoutez la dépendance suivante à votre modèle d’objet de projet POM.

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

#### Gradle

Ajoutez la dépendance à votre fichier `build.gradle`.

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

#### GitHub

Télécharger le JAR directement [depuis GitHub](https://github.com/stripe/stripe-java/releases/tag/v31.1.0)

### Installer le package Python de Stripe

Installez le package Stripe et importez-le dans votre code. Si vous partez de zéro et avez besoin d’un fichier `requirements.txt`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### pip

Installez le package via pip&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque stripe-python directement [depuis GitHub](https://github.com/stripe/stripe-python/releases/tag/v14.1.0).

### Installer la bibliothèque PHP de Stripe

Installez la bibliothèque avec Composer et initialisez-la avec votre clé API secrète. Si vous partez de zéro et avez besoin d’un fichier `composer.json`, vous pouvez également télécharger les fichiers à l’aide du lien de téléchargement dans l’éditeur de code.

#### Composer

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe-php directement [depuis GitHub](https://github.com/stripe/stripe-php/releases/tag/v19.1.0).

### Installer la bibliothèque Stripe Go

Ajoutez la dépendance à votre build et importez la bibliothèque. Si vous partez de zéro et avez besoin d’un fichier `go.mod`, téléchargez les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

#### Go

Assurez-vous d’effectuer l’initialisation avec les modules Go&nbsp;:

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

#### GitHub

Téléchargez le code source du module stripe-go directement [depuis GitHub](https://github.com/stripe/stripe-go/releases/tag/v85.0.0).

### Installer la bibliothèque Stripe.net

Installez le package avec .NET ou NuGet. Si vous partez de zéro, vous pouvez également télécharger les fichiers qui comprennent un fichier `.csproj` configuré.

#### dotnet

Installez la bibliothèque&nbsp;:

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

#### NuGet

Installez la bibliothèque&nbsp;:

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

#### GitHub

Télécharger le code source de la bibliothèque stripe.net directement [depuis GitHub](https://github.com/stripe/stripe-dotnet/releases/tag/v50.1.0).

### Installer la bibliothèque Stripe

Installez les packages et importez-les dans votre code. Si vous partez de zéro et qu’il vous faut un fichier `package.json`, vous pouvez également télécharger les fichiers du projet à l’aide du lien de téléchargement dans l’éditeur de code.

Installez les bibliothèques, puis initialisez le SDK Stripe avec les en-têtes bêta appropriés&nbsp;:

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

### Configurez votre clé secrète

Ajoutez votre clé secrète à votre serveur.

### Configurer les variables d’environnement

Ajoutez vos clés secrètes et publiques à un fichier `.env`. Next.js les charge automatiquement dans votre application en tant que [variable d’environnement](https://nextjs.org/docs/basic-features/environment-variables).

### Configurer les variables d’environnement

Ajoutez votre clé secrète à un fichier `.env`. Next.js la charge automatiquement dans votre application en tant que [variable d’environnement](https://nextjs.org/docs/basic-features/environment-variables).

### Configurez votre clé publique

Ajoutez votre clé publique à un fichier `.env`. React la charge automatiquement dans votre application en tant que [variable d’environnement](https://create-react-app.dev/docs/adding-custom-environment-variables/).

### Configurer Connect.js

Importez le module [@stripe/connect-js](https://github.com/stripe/connect-js).

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque @stripe/connect-js directement [depuis GitHub](https://github.com/stripe/connect-js).

### Importer React Connect.js

Importez le module [@stripe/react-connect-js](https://github.com/stripe/react-connect-js). React Connect.js est un wrapper léger autour des composants intégrés Connect qui vous permet d’ajouter des composants intégrés à n’importe quelle application React.

#### npm

Installez la bibliothèque&nbsp;:

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

#### GitHub

Téléchargez le code source de la bibliothèque @stripe/react-connect-js directement [depuis GitHub](https://github.com/stripe/react-connect-js).

### Ajouter l’image de marque de la plateforme

Pour utiliser l’inscription hébergée par Stripe, accédez d’abord à vos [paramètres d’inscription](https://dashboard.stripe.com/settings/connect/onboarding-interface) et personnalisez votre image de marque. Vous devez définir un nom d’entreprise, une icône et une couleur de marque.

### Ajouter un endpoint pour mettre en place un compte connecté

Définissez sur votre serveur un endpoint que votre client pourra appeler pour gérer la création d’un compte connecté.

### Créer un compte connecté

Créez un compte connecté en appelant l’API Stripe. Nous avons configuré les attributs utilisés en fonction des préférences que vous avez sélectionnées ci-dessus. Vous pouvez préremplir les informations de vérification, le profil d’entreprise de l’utilisateur et d’autres champs du [compte](https://docs.stripe.com/api/accounts/create.md) si votre plateforme les a déjà collectés.

### Créer un compte connecté

Créez un compte connecté en utilisant l’API Stripe. Nous avons configuré les attributs utilisés en fonction des préférences que vous avez sélectionnées ci-dessus. Vous pouvez préremplir les informations de vérification, le profil d’entreprise de l’utilisateur et d’autres champs sur le [compte](https://docs.stripe.com/api/v2/core/accounts/create.md) si votre plateforme les a déjà collectés.

### Indiquer le pays du compte

Lorsque vos comptes n’utilisent pas un Dashboard hébergé par Stripe, vous devez spécifier le pays du compte en amont.

### Indiquer le pays du compte

Vous devez spécifier à l’avance l’`identity.country` du compte.

### Appeler l’endpoint pour créer un compte connecté

Appelez l’endpoint que vous avez ajouté ci-dessus pour créer un compte connecté.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’inscription des utilisateurs intégrée. Vos comptes connectés sont intégrés à votre plateforme par le biais du composant Account Onboarding, qui est directement intégré dans votre application.

### Ajouter un endpoint pour créer une session de compte

Ajoutez un endpoint de serveur que votre client pourra appeler pour créer une AccountSession. Une AccountSession vous permet d’utiliser des composants intégrés Connect.js.

### Créer une AccountSession

Créez une [AccountSession](https://docs.stripe.com/api/account_sessions.md) en appelant l’API `v1/account_sessions`.

### Déléguer l’accès API à votre compte connecté

Précisez l’ID du compte connecté au nom duquel vous agissez.

### Activer le composant d’inscription de compte

Activez le composant `account_onboarding` pour l’AccountSession.

### Renvoyer la clé secrète du client

Demandez à votre endpoint de renvoyer la propriété `client_secret` de l’AccountSession.

### Initialiser Connect.js

`loadConnectAndInitialize` renvoie un objet StripeConnect, qui crée une instance StripeConnectInstance. Transmettez votre [clé publiable](https://docs.stripe.com/keys.md) ainsi qu’une fonction qui crée une AccountSession et renvoie son `client_secret`.

### Facultatif&nbsp;: styliser les composants intégrés Connect

Vous pouvez [personnaliser l’apparence du composant d’inscription](https://docs.stripe.com/connect/customize-connect-embedded-components.md) en transmettant une configuration `appearance` lorsque vous initialisez l’instance StripeConnect. Par défaut, les composants intégrés Connect héritent de la famille de polices de l’élément HTML parent, mais vous pouvez la remplacer en transmettant la palette de couleurs de votre entreprise.

### Inclure le composant d’inscription intégré de Connect

Ajoutez le composant d’inscription intégré de Connect. Après l’initialisation, StripeConnectInstance gère le contexte et traite les requêtes à Stripe à l’aide de la clé secrète du client et de la clé publique.

### Rediriger l’utilisateur une fois l’inscription terminée

Utilisez le rappel `onExit` pour faire avancer votre utilisateur. Le composant appelle `onExit` lorsque l’utilisateur a effectué l’inscription intégrée.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez sélectionné l’inscription hébergée par Stripe. Votre plateforme redirige vos comptes connectés vers une interface d’inscription comarquée et hébergée par Stripe à l’aide d’un [lien de compte](https://docs.stripe.com/api/account_links.md).

### Présentation

Selon votre [sélection de préférence](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’onboarding hébergé par Stripe. Votre plateforme redirige vos comptes connectés vers une interface d’onboarding co-brandée hébergée par Stripe en utilisant un [Compte Link](https://docs.stripe.com/api/v2/core/account-links.md).

### Créez un endpoint lien de compte

Ajoutez un endpoint sur votre serveur pour créer un lien de compte.

### Indiquez une URL de redirection

Une fois que votre compte connecté a terminé le flux d’inscription, il est redirigé vers l’URL de redirection. Cela ne signifie pas que toutes les informations ont été collectées ni que le compte connecté a satisfait toutes ses exigences, mais simplement qu’il est entré dans le flux et en est sorti sans aucun souci particulier.

### Indiquer une URL d’actualisation

Stripe redirige votre compte connecté vers l’URL d’actualisation lorsque le lien a expiré, qu’il a déjà été utilisé, que votre plateforme ne peut pas accéder au compte connecté ou que le compte est refusé. Faites en sorte que l’URL d’actualisation crée un nouveau lien de compte d’inscription et y redirige votre utilisateur.

### Appeler l’endpoint pour créer un lien de compte

Fournissez l’ID du compte connecté.

### Rediriger l’utilisateur vers l’URL

Redirigez l’utilisateur vers Stripe pour qu’il finalise l’inscription. Une fois l’inscription terminée, il est redirigé vers votre application.

### Gérer le retour du compte connecté

Affichez une page utile au compte connecté lorsqu’il quitte le flux d’inscription hébergé par Stripe.

### Gérer l’actualisation du lien de compte

Appelez votre endpoint pour actualiser le lien de compte au niveau de l’URL d’actualisation.

### Présentation

Selon [vos préférences](https://docs.stripe.com/connect/onboarding/quickstart.md#choose-onboarding-surface), vous avez choisi l’inscription des utilisateurs via l’API. Vos comptes connectés s’inscrivent sur votre plateforme par le biais d’un flux d’inscription que vous créez et qui appelle l’API de Stripe. Votre plateforme collecte toutes les informations de vérification requises.

### Ajouter un endpoint pour mettre à jour un compte

Appelez ce endpoint pour fournir les informations du compte à Stripe lorsque vous les collectez.

### Fournir des informations à Stripe

Indiquez le type d’entreprise comme exemple de données.

### Appeler le endpoint pour mettre à jour un compte

Fournissez l’ID du compte connecté.

### Faire avancer le flux d’inscription

Déterminez les [informations requises](https://docs.stripe.com/connect/custom/onboarding.md#establish-requirements) que vous devez recueillir. Créez un flux permettant à vos comptes connectés de les saisir et de les transmettre à Stripe.

### Accepter des paiements

Maintenant que vous avez inscrit un compte connecté, continuez à [créer des paiements directs](https://docs.stripe.com/connect/direct-charges.md).

### Accepter des paiements

Maintenant que vous avez inscrit un compte connecté, continuez à [créer des paiements indirects](https://docs.stripe.com/connect/destination-charges.md).

### Accepter des paiements

Maintenant que vous avez inscrit un compte connecté, continuez à [créer des paiements et transferts distincts](https://docs.stripe.com/connect/separate-charges-and-transfers.md).

### Continuer à développer l’inscription via l’API

Utilisez la documentation [sur les informations de vérification requises](https://docs.stripe.com/connect/required-verification-information.md) et développez un moyen pour vos comptes connectés d’effectuer l’inscription. Ensuite, continuez à [créer des paiements directs](https://docs.stripe.com/connect/direct-charges.md).

### Continuer à développer l’inscription via l’API

Utilisez la documentation [sur les informations de vérification requises](https://docs.stripe.com/connect/required-verification-information.md) et développez un moyen pour vos comptes connectés d’effectuer l’inscription. Ensuite, continuez à [créer des paiements indirects](https://docs.stripe.com/connect/destination-charges.md).

### Continuer à développer l’inscription via l’API

Utilisez la documentation [sur les informations de vérification requises](https://docs.stripe.com/connect/required-verification-information.md) et développez un moyen pour vos comptes connectés d’effectuer l’inscription. Continuez ensuite à [créer des paiements et transferts distincts](https://docs.stripe.com/connect/separate-charges-and-transfers.md).