Sending Payouts

    Pay out funds received from credit cards to third-party bank accounts or debit cards. If you need help after reading this, search our documentation or check out answers to common questions. You can even chat live with other developers in #stripe on freenode.

    Once you've received payments through Stripe, you can create payouts through the API to send funds to arbitrary third-party bank accounts or debit cards.

    This feature is currently only available for U.S. Stripe accounts. When sending to a bank account, the recipient's bank account must be in the U.S. When sending to a debit card, payouts must be less than $3000, and the recipient's card must be a U.S. Visa or Mastercard debit card that is not prepaid.

    Stripe sends automatic payouts to your bank account on a two-day rolling basis. Once you switch to manual payouts, though, you'll no longer receive automatic Stripe payouts. Payments you receive will instead accumulate in your Stripe balance. The funds from a payment will become available for you to pay out to third parties (or yourself) after two days.

    Collecting recipient details

    You can send payouts to one of two destinations: a bank account or a debit card. With either, you'll also need to collect a legal name. The recipient name is required for the compliance checks that Stripe performs, such as matching against the OFAC list. If the recipient is an individual, you'll need to collect their full legal name; if they're a business, the legal corporation name.

    In either case, the easiest way to collect this information is to use Stripe.js to tokenize the details. For a bank account, grab the account token on your server in the POST parameters (submitted by your form) and use that token to create a recipient:

    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Get the bank account details submitted by the form
    token_id = params[:stripeToken]
    
    # Create a Recipient
    recipient = Stripe::Recipient.create(
      :name => "John Doe",
      :type => "individual",
      :email => "payee@example.com",
      :bank_account => token_id
    )
    
    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Get the bank account details submitted by the form
    token_id = request.POST['stripeToken']
    
    # Create a Recipient
    recipient = stripe.Recipient.create(
      name="John Doe",
      type="individual",
      email="payee@example.com",
      bank_account=token_id
    )
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Get the bank account details submitted by the form
    $token_id = $_POST['stripeToken'];
    
    // Create a Recipient
    $recipient = \Stripe\Recipient::create(array(
      "name" => "John Doe",
      "type" => "individual",
      "bank_account" => $token_id,
      "email" => "payee@example.com")
    );
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";
    
    // Get the bank account details submitted by the form
    String tokenID = request.getParameter("stripeToken");
    
    // Create a Recipient
    Map<String, Object> recipientParams = new HashMap<String, Object>();
    recipientParams.put("name", "John Doe");
    recipientParams.put("type", "individual");
    recipientParams.put("bank_account", tokenID);
    recipientParams.put("email", "payee@example.com");
    
    Recipient recipient = Recipient.create(recipientParams);
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    var stripe = require("stripe")("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Get the bank account details submitted by the form
    var token_id = request.body.stripeToken; // Using Express
    
    // Create a Recipient
    stripe.recipients.create({
      name: "John Doe",
      type: "individual",
      bank_account: token_id,
      email: "payee@example.com"
    }, function(err, recipient) {
      // recipient;
    });
    

    The process is similar for debit cards using Stripe.js. Grab the debit card information from your POST parameters to create a recipient:

    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Get the card details submitted by the form
    token_id = params[:stripeToken]
    
    # Create a Recipient
    recipient = Stripe::Recipient.create(
      :name => "John Doe",
      :type => "individual",
      :email => "payee@example.com",
      :card => token_id
    )
    
    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Get the card details submitted by the form
    token_id = request.POST['stripeToken']
    
    # Create a Recipient
    recipient = stripe.Recipient.create(
      name="John Doe",
      type="individual",
      email="payee@example.com",
      card=token_id
    )
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Get the card details submitted by the form
    $token_id = $_POST['stripeToken'];
    
    // Create a Recipient
    $recipient = \Stripe\Recipient::create(array(
      "name" => "John Doe",
      "type" => "individual",
      "card" => $token_id,
      "email" => "payee@example.com")
    );
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";
    
    // Get the card details submitted by the form
    String tokenID = request.getParameter("stripeToken");
    
    // Create a Recipient
    Map<String, Object> recipientParams = new HashMap<String, Object>();
    recipientParams.put("name", "John Doe");
    recipientParams.put("type", "individual");
    recipientParams.put("card", tokenID);
    recipientParams.put("email", "payee@example.com");
    
    Recipient recipient = Recipient.create(recipientParams);
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    var stripe = require("stripe")("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Get the card details submitted by the form
    var token = request.body.stripeToken; // Using Express
    
    // Create a Recipient
    stripe.recipients.create({
      name: "John Doe",
      type: "individual",
      card: token,
      email: "payee@example.com"
    }, function(err, recipient) {
      // recipient;
    });
    

    Verifying recipients

    It's important that you verify the identity of your recipients and that the name provided to Stripe is their full legal name. If a recipient receives a large volume of payouts, or if there are any anomalies, we may need to contact you for additional information before we can process further payouts to them.

    The broader context here is that there are many laws around money transmission in order to guard against money laundering, terrorist financing, etc. Stripe does its best to make it easy for you to build great products, using simple abstractions, while handling as much of the compliance burden as possible.

    Creating payouts

    Once you've created a recipient, you can initiate a payout with a single API call. While doing so, you can also specify the description that appears on the recipient's account statement.

    The returned payout object describes the status of the payout and specifies when the payout should be available in the destination bank account or debit card account.

    To pay out money to a bank account:

    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the specified recipient
    payout = Stripe::Payout.create(
      :amount => 1000, # amount in cents
      :currency => "usd",
      :recipient => recipient_id,
      :bank_account => bank_account_id,
      :statement_descriptor => "JULY SALES"
    )
    
    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the specified recipient
    payout = stripe.Payout.create(
        amount=1000, # Amount in cents
        currency="usd",
        recipient=recipient_id,
        bank_account=bank_account_id,
        statement_descriptor="JUNE SALES"
    )
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the specified recipient
    $payout = \Stripe\Payout::create(array(
      "amount" => 1000, // amount in cents
      "currency" => "usd",
      "recipient" => $recipient_id,
      "bank_account" => $bank_account_id,
      "statement_descriptor" => "JULY SALES")
    );
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the specified recipient
    Map<String, Object> payoutParams = new HashMap<String, Object>();
    payoutParams.put("amount", 1000); // amount in cents
    payoutParams.put("currency", "usd");
    payoutParams.put("recipient", recipientId);
    payoutParams.put("bank_account", bankAccountId);
    payoutParams.put("statement_descriptor", "JULY SALES");
    
    Payout payout = Payout.create(payoutParams);
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    var stripe = require("stripe")("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the specified recipient
    stripe.payouts.create({
      amount: 1000, // amount in cents
      currency: "usd",
      recipient: recipientId,
      bank_account: bank_account_id,
      statement_descriptor: "JULY SALES"
    }, function(err, payout) {
      // payout;
    });
    

    The API call is similar for paying out to a debit card:

    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the specified recipient
    payout = Stripe::Payout.create(
      :amount => 1000, # amount in cents
      :currency => "usd",
      :recipient => recipient_id,
      :card => card_id,
      :statement_descriptor => "JULY SALES"
    )
    
    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the specified recipient
    payout = stripe.Payout.create(
        amount=1000, # Amount in cents
        currency="usd",
        recipient=recipient_id,
        card=card_id,
        statement_descriptor="JUNE SALES"
    )
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the specified recipient
    $payout = \Stripe\Payout::create(array(
      "amount" => 1000, // amount in cents
      "currency" => "usd",
      "recipient" => $recipient_id,
      "card" => $card_id,
      "statement_descriptor" => "JULY SALES")
    );
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";
    
    // Create a payout to the specified recipient
    Map<String, Object> payoutParams = new HashMap<String, Object>();
    payoutParams.put("amount", 1000); // amount in cents
    payoutParams.put("currency", "usd");
    payoutParams.put("recipient", recipientId);
    payoutParams.put("card", cardId);
    payoutParams.put("statement_descriptor", "JULY SALES");
    
    Payout payout = Payout.create(payoutParams);
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    var stripe = require("stripe")("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the specified recipient
    stripe.payouts.create({
      amount: 1000, // amount in cents
      currency: "usd",
      recipient: recipientId,
      card: cardId,
      statement_descriptor: "JULY SALES"
    }, function(err, payout) {
      // payout;
    });
    

    Note that if the recipient only has one card, you may omit the card parameter. However, if your recipient has both a card and a bank account associated, you will need to either pass in the card or bank_account parameter.

    Payout timeline

    Unlike charging a credit card, sending a payout is not synchronous. For bank accounts, payouts will be available in the bank account the next business day if created before 21:00 UTC. If the payout fails (due to a typo in the bank details, for example), it can take up to five business days for Stripe to be notified.

    Payouts to debit cards can take 1 to 2 days to complete. However, unlike with bank accounts, we'll know instantaneously if the debit card is not valid when it is added to the recipient.

    Here's what the flow looks like:

    • A payout is created via the API. At this point, the payout's status is pending.
    • You receive a payout.paid webhook when the payout is expected to be available in the recipient's bank account or debit card. However, this webhook does not guarantee that the payout was actually successful.
    • If the payout fails, you'll receive a payout.failed webhook within five business days (that's unfortunately how long some banks take to return payouts) and the payout will be marked as failed.
    • You can safely assume the payout was successful if you don't receive a payout.failed webhook within five business days.

    Handling payout failures

    If a payout fails, it will most likely be because of incorrect bank account or debit card details. You should update the recipient object with the correct details and retry the payout.

    Sending payouts to yourself

    Once you enable manual payouts, Stripe will no longer send automatic payouts to your bank account (if we did, there'd be no funds left for you to pay others out with!). You need to explicitly create a payout if you'd like to pay out funds from your Stripe balance to your bank account.

    If you set the recipient of the payout as self, the payout will be sent to the bank account associated with your Stripe account. There are no fees for these payouts.

    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the bank account associated with your Stripe account
    payout = Stripe::Payout.create(
      :amount => 1000, # amount in cents
      :currency => "usd",
      :recipient => "self",
      :statement_descriptor => "JULY SALES"
    )
    
    # Set your secret key: remember to change this to your live secret key in production
    # See your keys here: https://dashboard.stripe.com/account/apikeys
    stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"
    
    # Create a payout to the bank account associated with your Stripe account
    payout = stripe.Payout.create(
        amount=1000, # Amount in cents
        currency="usd",
        recipient="self",
        statement_descriptor="JUNE SALES"
    )
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the bank account associated with your Stripe account
    $payout = \Stripe\Payout::create(array(
      "amount" => 1000, // amount in cents
      "currency" => "usd",
      "recipient" => "self",
      "statement_descriptor" => "JULY SALES")
    );
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    \Stripe\Stripe::setApiKey("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the bank account associated with your Stripe account
    Map<String, Object> payoutParams = new HashMap<String, Object>();
    payoutParams.put("amount", 1000); // amount in cents
    payoutParams.put("currency", "usd");
    payoutParams.put("recipient", "self");
    payoutParams.put("statement_descriptor", "JULY SALES");
    
    Payout payout = Payout.create(payoutParams);
    
    // Set your secret key: remember to change this to your live secret key in production
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    var stripe = require("stripe")("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
    
    // Create a payout to the bank account associated with your Stripe account
    stripe.payouts.create({
      amount: 1000, // amount in cents
      currency: "usd",
      recipient: "self",
      statement_descriptor: "JULY SALES"
    }, function(err, payout) {
      // payout;
    });
    

    Testing

    You can use our test bank account numbers, debit card numbers, and tax IDs to test sending payouts.

    Errors

    Invalid bank account

    You'll get an error when creating a recipient if the routing number does not correspond to a valid U.S. bank account. For account numbers, we won't know if the account exists until a successful payout is made.

    {
      "error": {
        "message": "Not a valid US routing number",
        "type": "invalid_request_error"
      }
    }

    Insufficient funds

    If the funds in your Stripe account aren't enough to cover a payout, the payout will not be created:

    {
      "error": {
        "message": "Insufficient funds in Stripe account",
        "type": "invalid_request_error"
      }
    }

    Invalid debit card

    You'll get an error when creating a recipient if the debit card number isn't a U.S. Mastercard or Visa debit card. The card cannot be prepaid.

    {
      "error": {
        "message": "This card doesn't appear to be a non-prepaid Visa or Mastercard debit card.",
        "type": "invalid_request_error"
      }
    }