Pay out money

    Use top-ups to add money to your Stripe balance and pay out your sellers or service providers. U.S. only

    Overview

    This guide walks you through how to add funds to your Stripe balance and transfer the funds into your users’ bank accounts, without processing payments through Stripe. We’ll illustrate these concepts with an example of a Q&A product that pays its writers a portion of the advertising revenue that their answers generate.

    To use top-ups, your platform must be on a manual payout schedule. You can configure your schedule in your payout settings.

    Prerequisites

    1. Register your platform.
    2. Activate your account.
    3. Fill out your platform profile.

    1 Set up Stripe Server-side

    Install Stripe’s official libraries so you can access the API from your application:

    # Available as a gem sudo gem install stripe
    # If you use bundler, you can add this line to your Gemfile gem 'stripe'
    # Install through pip pip install --upgrade stripe
    # Or find the Stripe package on http://pypi.python.org/pypi/stripe/
    # Install the PHP library via Composer composer require stripe/stripe-php
    # Or download the source directly: https://github.com/stripe/stripe-php/releases
    /* For Gradle, add the following dependency to your build.gradle and replace {VERSION} with the version number you want to use from - https://mvnrepository.com/artifact/com.stripe/stripe-java or - https://github.com/stripe/stripe-java/releases/latest */ implementation "com.stripe:stripe-java:{VERSION}"
    <!-- For Maven, add the following dependency to your POM and replace {VERSION} with the version number you want to use from - https://mvnrepository.com/artifact/com.stripe/stripe-java or - https://github.com/stripe/stripe-java/releases/latest --> <dependency> <groupId>com.stripe</groupId> <artifactId>stripe-java</artifactId> <version>{VERSION}</version> </dependency>
    # For other environments, manually install the following JARs: # - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest # - Google Gson from https://github.com/google/gson
    # Install via npm npm install --save stripe
    # Install via go go get github.com/stripe/stripe-go
    // Then import the package import ( "github.com/stripe/stripe-go" )
    # Install via dotnet dotnet add package Stripe.net dotnet restore
    # Or install via NuGet PM> Install-Package Stripe.net

    2 Create a connected account

    When a user (seller or service provider) signs up on your platform, create a user Account (referred to as a connected account) so you can accept payments and move funds to their bank account. Connected accounts represent your users in Stripe’s API and facilitate the collection of onboarding requirements so Stripe can verify the user’s identity. For a Q&A product that pays for answers, the connected account represents the writer.

    Step 2.1: Add an authentication button Client-side

    Add an OAuth link to your website so the user can sign up for your platform:

    https://connect.stripe.com/express/oauth/authorize?client_id=ca_32D88BD1qLklliziD7gYQvctJIhWBSQ7&state={STATE_VALUE}&suggested_capabilities[]=transfers&stripe_user[email]=user@example.com
    • client_id - This can be found in your platform settings. If you’re testing your integration, enable View test data in the Dashboard.
    • state - Use this argument to prevent CSRF attacks. It should be a unique, not guessable value that’s generated and saved on your server. Stripe passes it back to your redirect after the user finishes the onboarding flow.
    • suggested_capabilities - Specify the capabilities you want to add to the connected account. Capabilities define what a connected account is allowed to do. For our Q&A example, we want the writer to have the transfers capability so they can receive transfers after fulfilling their onboarding requirements.
    • stripe_user - Use these arguments to pre-fill fields with information that you’ve already collected from the user. For example, if you collected the writer’s email when they signed up on the app, you can provide this information to Stripe in this link.

    Click the OAuth link below to see an example flow from the user’s perspective.

    Connect with Stripe

    Step 2.2: Save the account ID Server-side

    In platform settings, specify where the user should be redirected to after they’ve completed the OAuth flow with redirect_uri.

    For example, if your redirect URI is https://www.example.com/connect/oauth, Stripe might redirect to https://www.example.com/connect/oauth?state=s_987654321&authorization_code=ac_123456789.

    Write a GET handler to extract the parameters from the URI, verify the state against the state you saved on your server, and send the token to Stripe’s API:

    curl https://connect.stripe.com/oauth/token \ -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \ -d code=ac_123456789 \ -d grant_type=authorization_code
    # Using Sinatra. require 'sinatra' require 'stripe' set :port, 4242 # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' get '/' do # Display landing page. content_type 'text/html' send_file File.join('./index.html') end get '/connect/oauth' do content_type 'application/json' # Assert the state matches the state you provided in the OAuth link (optional). state = params[:state] if !state_matches?(state) status 403 return {error: 'Incorrect state parameter: ' + state}.to_json end # Send the authorization code to Stripe's API. code = params[:code] begin response = Stripe::OAuth.token({ grant_type: 'authorization_code', code: code, }) rescue Stripe::OAuth::InvalidGrantError status 400 return {error: 'Invalid authorization code: ' + code}.to_json rescue Stripe::StripeError status 500 return {error: 'An unknown error occurred.'}.to_json end connected_account_id = response.stripe_user_id save_account_id(connected_account_id) # Render some HTML or redirect to a different page. status 200 {success: true}.to_json end def state_matches?(state_parameter) # Load the same state value that you randomly generated for your OAuth link. saved_state = '{{ STATE }}' saved_state == state_parameter end def save_account_id(id) # Save the connected account ID from the response to your database. puts 'Connected account ID: ' + id end
    import stripe import json # Using Flask. from flask import ( Flask, render_template, request, ) app = Flask(__name__, static_folder=".", static_url_path="", template_folder=".") @app.route('/', methods=['GET']) def get_example(): # Display landing page. return render_template('index.html') # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' @app.route("/connect/oauth", methods=["GET"]) def handle_oauth_redirect(): # Assert the state matches the state you provided in the OAuth link (optional). state = request.args.get("state") if not state_matches(state): return json.dumps({"error": "Incorrect state parameter: " + state}), 403 # Send the authorization code to Stripe's API. code = request.args.get("code") try: response = stripe.OAuth.token(grant_type="authorization_code", code=code,) except stripe.oauth_error.OAuthError as e: return json.dumps({"error": "Invalid authorization code: " + code}), 400 except Exception as e: return json.dumps({"error": "An unknown error occurred."}), 500 connected_account_id = response["stripe_user_id"] save_account_id(connected_account_id) # Render some HTML or redirect to a different page. return json.dumps({"success": True}), 200 def state_matches(state_parameter): # Load the same state value that you randomly generated for your OAuth link. saved_state = "{{ STATE }}" return saved_state == state_parameter def save_account_id(id): # Save the connected account ID from the response to your database. print("Connected account ID: ", id) if __name__ == "__main__": app.run(port=4242)
    <?php // Using Slim. use Slim\Http\Request; use Slim\Http\Response; use Stripe\Stripe; require_once('vendor/autoload.php'); $app = new \Slim\App; // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys \Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); $app->get('/', function (Request $request, Response $response, array $args) { // Display landing page. return $response->write(file_get_contents('./index.html')); }); $app->get('/connect/oauth', function ($request, $response, $next) { extract($request->getQueryParams()); // Assert the state matches the state you provided in the OAuth link (optional). if (!stateMatches($state)) return $response->withStatus(403)->withJson(array('error' => 'Incorrect state parameter: ' . $state)); // Send the authorization code to Stripe's API. $code = $request->getQueryParam('code'); try { $stripeResponse = \Stripe\OAuth::token([ 'grant_type' => 'authorization_code', 'code' => $code, ]); } catch (\Stripe\Error\OAuth\InvalidGrant $e) { return $response->withStatus(400)->withJson(array('error' => 'Invalid authorization code: ' . $code)); } catch (Exception $e) { return $response->withStatus(500)->withJson(array('error' => 'An unknown error occurred.')); } $connectedAccountId = $stripeResponse->stripe_user_id; saveAccountId($connectedAccountId); // Render some HTML or redirect to a different page. return $response->withStatus(200)->withJson(array('success' => true)); }); function stateMatches($stateParameter) { // Load the same state value that you randomly generated for your OAuth link. $savedState = '{{ STATE }}'; return $savedState == $stateParameter; }; function saveAccountId($id) { // Save the connected account ID from the response to your database. echo 'Connected account ID: ' . $id; }; $app->run();
    // Using Express const express = require('express'); const app = express(); app.use(express.json()); const { resolve } = require("path"); // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); app.get("/", (req, res) => { // Display landing page. const path = resolve("./index.html"); res.sendFile(path); }); app.get("/connect/oauth", async (req, res) => { const { code, state } = req.query; // Assert the state matches the state you provided in the OAuth link (optional). if(!stateMatches(state)) { return res.status(403).json({ error: 'Incorrect state parameter: ' + state }); } var error; // Send the authorization code to Stripe's API. stripe.oauth.token({ grant_type: 'authorization_code', code }).then( (response) => { var connected_account_id = response.stripe_user_id; saveAccountId(connected_account_id); // Render some HTML or redirect to a different page. return res.status(200).json({success: true}); }, (err) => { if (err.type === 'StripeInvalidGrantError') { return res.status(400).json({error: 'Invalid authorization code: ' + code}); } else { return res.status(500).json({error: 'An unknown error occurred.'}); } } ); }); const stateMatches = (state_parameter) => { // Load the same state value that you randomly generated for your OAuth link. const saved_state = 'sv_53124'; return saved_state == state_parameter; } const saveAccountId = (id) => { // Save the connected account ID from the response to your database. console.log('Connected account ID: ' + id); } app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));
    package com.stripe.sample; import com.google.gson.Gson; import com.stripe.Stripe; import com.stripe.net.OAuth; import com.stripe.model.oauth.TokenResponse; import com.stripe.exception.StripeException; import com.stripe.exception.oauth.InvalidGrantException; import spark.Response; import java.nio.file.Paths; import java.util.HashMap; import java.util.Map; // Using Spark. import static spark.Spark.*; import io.github.cdimascio.dotenv.Dotenv; public class Server { private static Gson gson = new Gson(); public static void main(String[] args) { port(4242); // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"; staticFiles.externalLocation("../client"); get("/connect/oauth", (request, response) -> { // Assert the state matches the state you provided in the OAuth link (optional). String state = request.queryParams("state"); if (!stateMatches(state)) { return buildResponse( response, 403, "error", "Incorrect state parameter: " + state ); } // Send the authorization code to Stripe's API. String code = request.queryParams("code"); Map<String, Object> params = new HashMap<>(); params.put("grant_type", "authorization_code"); params.put("code", code); try { TokenResponse stripeResponse = OAuth.token(params, null); // Save the connected account ID from the response to your database. String connectedAccountId = stripeResponse.getStripeUserId(); saveAccountId(connectedAccountId); // Render some HTML or redirect to a different page. return buildResponse(response, 200, "success", "Request succeeded."); } catch (InvalidGrantException e) { // There's a problem with the authorization code. return buildResponse( response, 400, "error", "Invalid authorization code: " + code ); } catch (StripeException e) { // All other errors. return buildResponse( response, 500, "error", "An unknown error occurred." ); } }); } private static boolean stateMatches(String parameterState) { // Load the same state value that you randomly generated for your OAuth link. String savedState = "{{ STATE }}"; return savedState.equals(parameterState); } private static void saveAccountId(String id) { System.out.println("Connected account ID: " + id); } private static String buildResponse( Response response, int statusCode, String type, String message ) { response.status(statusCode); Map<String, String> errorResponse = new HashMap<>(); errorResponse.put(type, message); return gson.toJson(errorResponse); } }
    package main import ( "encoding/json" "log" "fmt" "net/http" "github.com/stripe/stripe-go" "github.com/stripe/stripe-go/oauth" "os" ) type CreateOAuthResponse struct { Success bool `json:"success"` } func main() { // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc" // Display landing page. fs := http.FileServer(http.Dir("static")) http.Handle("/", fs) http.HandleFunc("/connect/oauth", handleOauthRedirect) addr := "localhost:4242" log.Printf("Listening on %s ...", addr) log.Fatal(http.ListenAndServe(addr, nil)) } func handleOauthRedirect(w http.ResponseWriter, r *http.Request) { query := r.URL.Query() // Assert the state matches the state you provided in the OAuth link (optional). state := query.Get("state") if !stateMatches(state, w) { http.Error(w, fmt.Sprintf("Invalid state parameter: %s", state), http.StatusForbidden) return } // Send the authorization code to Stripe's API. code := query.Get("code") params := &stripe.OAuthTokenParams{ GrantType: stripe.String("authorization_code"), Code: &code, } token, err := oauth.New(params) if err != nil { stripeErr := err.(*stripe.Error) if (stripeErr.OAuthError == "invalid_grant") { http.Error(w, fmt.Sprintf("Invalid authorization code: %s", code), http.StatusBadRequest) } else { http.Error(w, "An unknown error occurred.", http.StatusInternalServerError) } return } connectedAccountId := token.StripeUserID saveAccountId(connectedAccountId) // Render some HTML or redirect to a different page. json.NewEncoder(w).Encode(CreateOAuthResponse{ Success: true, }) } func stateMatches(state_parameter string, w http.ResponseWriter) bool { // Load the same state value that you randomly generated for your OAuth link. saved_state := "{{ STATE }}" return saved_state == state_parameter } func saveAccountId(id string) { // Save the connected account ID from the response to your database. log.Println("Connected account ID: " + id) }
    using System; using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Microsoft.AspNetCore.Http; using Stripe; using Newtonsoft.Json; namespace Controllers { public class ConnectController : Controller { private readonly StripeClient client; private readonly IOptions<StripeOptions> options; private readonly ILogger<ConnectController> logger; public ConnectController( IOptions<StripeOptions> options, ILogger<ConnectController> logger, ) { // Set your secret key: remember to switch to your live secret key in production // See your keys here: https://dashboard.stripe.com/account/apikeys this.client = new StripeClient("sk_test_4eC39HqLyjWDarjtT1zdp7dc"); this.options = options; this.logger = logger; } [HttpGet("/connect/oauth")] public IActionResult HandleOAuthRedirect( [FromQuery] string state, [FromQuery] string code ) { var service = new OAuthTokenService(client); // Assert the state matches the state you provided in the OAuth link (optional). if (!StateMatches(state)) { return StatusCode( StatusCodes.Status403Forbidden, Json(new { Error = String.Format("Incorrect state parameter: {0}", state) }) ); } // Send the authorization code to Stripe's API. var options = new OAuthTokenCreateOptions { GrantType = "authorization_code", Code = code, }; OAuthToken response = null; try { response = service.Create(options); } catch (StripeException e) { if (e.StripeError != null && e.StripeError.Error == "invalid_grant") { return StatusCode( StatusCodes.Status400BadRequest, Json(new { Error = String.Format("Invalid authorization code: {0}", code) }) ); } else { return StatusCode( StatusCodes.Status500InternalServerError, Json(new { Error = "An unknown error occurred." }) ); } } var connectedAccountId = response.StripeUserId; SaveAccountId(connectedAccountId); // Render some HTML or redirect to a different page. return new OkObjectResult(Json(new { Success = true })); } private bool StateMatches(string stateParameter) { // Load the same state value that you randomly generated for your OAuth link. var savedState = "{{ STATE }}"; return savedState == stateParameter; } private void SaveAccountId(string id) { // Save the connected account ID from the response to your database. logger.LogInformation($"Connected account ID: {id}"); } } }

    Make sure to save the stripe_user_id parameter that’s returned to your database. This is your connected account’s ID and begins with acct_. You will need it later to transfer funds to the account.

    Step 2.3: Customize your signup form

    The default Express signup form looks like this:

    In your platform settings, customize your Express signup form by changing the color and logos that users see when they click your Connect link.

    3 Top-up your balance

    Add funds to your platform’s balance from a linked bank account and transfer funds to your connected accounts.

    Step 3.1: Verifying your bank account

    You must use a verified bank account to top up your platform account. You’ll go through the verification process in the Dashboard when you first attempt to create a top-up from an unverified bank account.

    To initiate a top-up, go to the Balance section in the Dashboard.

    If your bank account is unverified, you’ll need to confirm two microdeposits from Stripe. These deposits will appear on your online banking statement within 1-2 business days. You’ll see AMNTS for the statement description and the values of the two microdeposits.

    Stripe will notify you in the Dashboard and via email when the microdeposits should have arrived in your account. To complete the verification process, click the Dashboard notification in the Balance section, enter the two microdeposit amounts, and click Verify account.

    Step 3.2: Creating Top-ups

    Use the Dashboard or the API to create a top-up.

    Dashboard

    1. In the Dashboard, go to the Balance section.
    2. In the Top up balance window, enter an amount in USD.
    3. In the resulting modal window (shown below), enter an amount in USD.
    4. Verify the top-up amount and then click Top up balance.
    5. After the funds are available in your platform’s Stripe balance, you can transfer funds to a connected account via the API or the Dashboard. In the Dashboard, transfer funds to a connected account by clicking Send funds in the the Balance section on the connected account’s detail page.

    API

    curl https://api.stripe.com/v1/topups \ -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \ -d amount=2000 \ -d currency=usd \ -d description="Top-up for week of May 31" \ -d statement_descriptor="Weekly top-up"
    # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' topup = Stripe::Topup.create({ amount: 2000, currency: 'usd', description: 'Top-up for week of May 31', statement_descriptor: 'Weekly top-up', })
    # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' topup = stripe.Topup.create( amount=2000, currency='usd', description='Top-up for week of May 31', statement_descriptor='Weekly top-up', )
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys \Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); $topup = \Stripe\Topup::create([ 'amount' => 2000, 'currency' => 'usd', 'description' => 'Top-up for week of May 31', 'statement_descriptor' => 'Weekly top-up', ]);
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"; TopupCreateParams params = TopupCreateParams.builder() .setAmount(2000L) .setCurrency("usd") .setDescription("Top-up for week of May 31") .setStatementDescriptor("Weekly top-up") .build(); Topup topup = Topup.create(params);
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); const topup = await stripe.topups.create({ amount: 2000, currency: 'usd', description: 'Top-up for week of May 31', statement_descriptor: 'Weekly top-up', });
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc" params := &stripe.TopupParams{ Amount: stripe.Int64(2000), Currency: stripe.String(string(stripe.CurrencyUSD)), Description: stripe.String("Top-up for week of May 31"), StatementDescriptor: stripe.String("Weekly top-up"), } t, _ := topup.New(params)
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"; var options = new TopupCreateOptions { Amount = 2000, Currency = "usd", Description = "Top-up for week of May 31", StatementDescriptor = "Weekly top-up", }; var service = new TopupService(); var topup = service.Create(options);

    When you transfer funds, a statement descriptor appears on your banking statement for the transaction. The default statement descriptor is “Top-up.” You can customize the statement descriptor and internal description for the top-up.

    Viewing Top-ups

    View your top-ups in the Dashboard on the Top-ups tab under the Balance page. Each top-up has a unique ID in the format tu_XXXXXX, which you can see on the detailed view for the top-up.

    Settlement timing

    Top-ups can take 5-6 business days to become available in your Stripe balance. You can request a review of your account for faster settlement timing in the Dashboard.

    As we learn more about your account, Stripe might be able to decrease your settlement timing automatically.

    4 Pay out to your user

    You can transfer available funds to a connected account using the API. For example, make the following call to transfer $9 to an account:

    curl https://api.stripe.com/v1/transfers \ -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \ -d amount=1000 \ -d currency=usd \ -d destination="{{CONNECTED_STRIPE_ACCOUNT_ID}}"
    # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' transfer = Stripe::Transfer.create({ amount: 900, currency: "usd", destination: "{{CONNECTED_STRIPE_ACCOUNT_ID}}", })
    # Set your secret key. Remember to switch to your live secret key in production! # See your keys here: https://dashboard.stripe.com/account/apikeys stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc' transfer = stripe.Transfer.create( amount=1000, currency="usd", destination={{CONNECTED_STRIPE_ACCOUNT_ID}}", )
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys \Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); $transfer = \Stripe\Transfer::create([ "amount" => 1000, "currency" => "usd", "destination" => "{{CONNECTED_STRIPE_ACCOUNT_ID}}", ]);
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"; Map<String, Object> params = new HashMap<>(); params.put("amount", 1000); params.put("currency", "usd"); params.put("destination", "{{CONNECTED_STRIPE_ACCOUNT_ID}}"); Transfer transfer = Transfer.create(params);
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc'); const transfer = await stripe.transfers.create({ amount: 1000, currency: "usd", destination: "{{CONNECTED_STRIPE_ACCOUNT_ID}}", });
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc" params := &stripe.TransferParams{ Amount: stripe.Int64(1000), Currency: stripe.String(string(stripe.CurrencyUSD)), Destination: stripe.String("{{CONNECTED_STRIPE_ACCOUNT_ID}}"), } tr, _ := transfer.New(params)
    // Set your secret key. Remember to switch to your live secret key in production! // See your keys here: https://dashboard.stripe.com/account/apikeys StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"; var options = new TransferCreateOptions { Amount = 1000, Currency = "usd", Destination = "{{CONNECTED_STRIPE_ACCOUNT_ID}}" }; var service = new TransferService(); var Transfer = service.Create(options);

    By default, any funds that you transfer to a connected account accumulates in the connected account’s Stripe balance and is paid out on a daily rolling basis. You can change the payout schedule as needed.

    5 Complete and customize your integration

    You now have a working integration. From your account dashboard, you can view an account and its balance.

    Testing

    Use the test bank tokens provided in the Connect-specific testing resource to simulate flows for accounts and onboarding, payouts, and top-ups.

    Other resources

    You have completed the minimum steps required to build a working Connect integration. Based on your business needs, you can also do the following:

    Manage connected accounts

    Customize payments

    Was this page helpful?

    Feedback about this page?

    Thank you for helping improve Stripe's documentation. If you need help or have any questions, please consider contacting support.

    On this page