---
title: Access balances for a Financial Connections account
subtitle: Learn how to access an account's balances with your user's permission.
route: /financial-connections/balances
---

# Access balances for a Financial Connections account

Learn how to access an account's balances with your user's permission.

The Financial Connections API allows you to retrieve up-to-date balances of a [Financial Connections Account](https://docs.stripe.com/api/financial_connections/accounts.md).
Balance data is useful for a variety of applications, including reducing the risk of insufficient funds failures for ACH, underwriting, or building financial management tools.

You must have a completed Financial Connections registration to access {{data_type}} in live mode. Check your [Dashboard settings](https://dashboard.stripe.com/settings/financial-connections) to check the state of your registration or begin the registration process. Financial Connections test data is always available.

## Create a customer

We recommend that you create a *Customer* with an email address to represent your user, that you then attach to your payment.
Attaching a Customer object allows you to [list previously linked accounts ](https://docs.stripe.com/api/financial_connections/accounts/list.md) later.
By providing an email address on the Customer object, Financial Connections can improve the authentication flow by streamlining sign-in or sign-up for your user, depending on whether they’re a returning [Link](https://support.stripe.com/questions/link-for-financial-connections-support-for-businesses) user.

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new CustomerCreateOptions { Email = "{{CUSTOMER_EMAIL}}" };
var service = new CustomerService();
Customer customer = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.CustomerParams{Email: stripe.String("{{CUSTOMER_EMAIL}}")};
result, err := customer.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

CustomerCreateParams params = CustomerCreateParams.builder().setEmail("{{CUSTOMER_EMAIL}}").build();

Customer customer = Customer.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const customer = await stripe.customers.create({
  email: '{{CUSTOMER_EMAIL}}',
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

customer = stripe.Customer.create(email="{{CUSTOMER_EMAIL}}")
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$customer = $stripe->customers->create(['email' => '{{CUSTOMER_EMAIL}}']);
```

```ruby
Stripe.api_key = '<<secret key>>'

customer = Stripe::Customer.create({email: '{{CUSTOMER_EMAIL}}'})
```

## Request access to an account's balances

You must collect an account before you can access its balance data. To learn more about how to collect Financial Connections Accounts consult the integration guide most relevant to your use case: [accept payments](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md), [facilitate Connect payouts](https://docs.stripe.com/financial-connections/connect-payouts.md), or [build other-data powered products](https://docs.stripe.com/financial-connections/other-data-powered-products.md).

When collecting an account, you specify the data you need access to with the [permissions](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) parameter. The set of requested data permissions are viewable by the user in the [authentication flow](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow). Financial Connections Accounts are collectible through various integration paths, and how you specify the parameter varies slightly by API.

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new PaymentIntentCreateOptions
{
    Amount = 20000,
    Currency = "usd",
    Customer = "<<customer>>",
    PaymentMethodTypes = new List<string> { "us_bank_account" },
    PaymentMethodOptions = new PaymentIntentPaymentMethodOptionsOptions
    {
        UsBankAccount = new PaymentIntentPaymentMethodOptionsUsBankAccountOptions
        {
            FinancialConnections = new PaymentIntentPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
            {
                Permissions = new List<string> { "balances", "payment_method" },
            },
        },
    },
};
var service = new PaymentIntentService();
PaymentIntent paymentIntent = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(20000),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  Customer: stripe.String("<<customer>>"),
  PaymentMethodTypes: []*string{stripe.String("us_bank_account")},
  PaymentMethodOptions: &stripe.PaymentIntentPaymentMethodOptionsParams{
    USBankAccount: &stripe.PaymentIntentPaymentMethodOptionsUSBankAccountParams{
      FinancialConnections: &stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
        Permissions: []*string{
          stripe.String(string(stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
          stripe.String(string(stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
        },
      },
    },
  },
};
result, err := paymentintent.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setAmount(20000L)
    .setCurrency("usd")
    .setCustomer("<<customer>>")
    .addPaymentMethodType("us_bank_account")
    .setPaymentMethodOptions(
      PaymentIntentCreateParams.PaymentMethodOptions.builder()
        .setUsBankAccount(
          PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.builder()
            .setFinancialConnections(
              PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                .addPermission(
                  PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                )
                .addPermission(
                  PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

PaymentIntent paymentIntent = PaymentIntent.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const paymentIntent = await stripe.paymentIntents.create({
  amount: 20000,
  currency: 'usd',
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {
      financial_connections: {
        permissions: ['balances', 'payment_method'],
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

payment_intent = stripe.PaymentIntent.create(
  amount=20000,
  currency="usd",
  customer="<<customer>>",
  payment_method_types=["us_bank_account"],
  payment_method_options={
    "us_bank_account": {"financial_connections": {"permissions": ["balances", "payment_method"]}},
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$paymentIntent = $stripe->paymentIntents->create([
  'amount' => 20000,
  'currency' => 'usd',
  'customer' => '<<customer>>',
  'payment_method_types' => ['us_bank_account'],
  'payment_method_options' => [
    'us_bank_account' => [
      'financial_connections' => ['permissions' => ['balances', 'payment_method']],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

payment_intent = Stripe::PaymentIntent.create({
  amount: 20000,
  currency: 'usd',
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {financial_connections: {permissions: ['balances', 'payment_method']}},
  },
})
```

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new SetupIntentCreateOptions
{
    Customer = "<<customer>>",
    PaymentMethodTypes = new List<string> { "us_bank_account" },
    PaymentMethodOptions = new SetupIntentPaymentMethodOptionsOptions
    {
        UsBankAccount = new SetupIntentPaymentMethodOptionsUsBankAccountOptions
        {
            FinancialConnections = new SetupIntentPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
            {
                Permissions = new List<string> { "balances", "payment_method" },
            },
        },
    },
};
var service = new SetupIntentService();
SetupIntent setupIntent = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.SetupIntentParams{
  Customer: stripe.String("<<customer>>"),
  PaymentMethodTypes: []*string{stripe.String("us_bank_account")},
  PaymentMethodOptions: &stripe.SetupIntentPaymentMethodOptionsParams{
    USBankAccount: &stripe.SetupIntentPaymentMethodOptionsUSBankAccountParams{
      FinancialConnections: &stripe.SetupIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
        Permissions: []*string{
          stripe.String(string(stripe.SetupIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
          stripe.String(string(stripe.SetupIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
        },
      },
    },
  },
};
result, err := setupintent.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

SetupIntentCreateParams params =
  SetupIntentCreateParams.builder()
    .setCustomer("<<customer>>")
    .addPaymentMethodType("us_bank_account")
    .setPaymentMethodOptions(
      SetupIntentCreateParams.PaymentMethodOptions.builder()
        .setUsBankAccount(
          SetupIntentCreateParams.PaymentMethodOptions.UsBankAccount.builder()
            .setFinancialConnections(
              SetupIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                .addPermission(
                  SetupIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                )
                .addPermission(
                  SetupIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

SetupIntent setupIntent = SetupIntent.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const setupIntent = await stripe.setupIntents.create({
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {
      financial_connections: {
        permissions: ['balances', 'payment_method'],
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

setup_intent = stripe.SetupIntent.create(
  customer="<<customer>>",
  payment_method_types=["us_bank_account"],
  payment_method_options={
    "us_bank_account": {"financial_connections": {"permissions": ["balances", "payment_method"]}},
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$setupIntent = $stripe->setupIntents->create([
  'customer' => '<<customer>>',
  'payment_method_types' => ['us_bank_account'],
  'payment_method_options' => [
    'us_bank_account' => [
      'financial_connections' => ['permissions' => ['balances', 'payment_method']],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

setup_intent = Stripe::SetupIntent.create({
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {financial_connections: {permissions: ['balances', 'payment_method']}},
  },
})
```

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new Stripe.FinancialConnections.SessionCreateOptions
{
    AccountHolder = new Stripe.FinancialConnections.SessionAccountHolderOptions
    {
        Type = "customer",
        Customer = "<<customer>>",
    },
    Permissions = new List<string> { "balances" },
};
var service = new Stripe.FinancialConnections.SessionService();
Stripe.FinancialConnections.Session session = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.FinancialConnectionsSessionParams{
  AccountHolder: &stripe.FinancialConnectionsSessionAccountHolderParams{
    Type: stripe.String(string(stripe.FinancialConnectionsSessionAccountHolderTypeCustomer)),
    Customer: stripe.String("<<customer>>"),
  },
  Permissions: []*string{
    stripe.String(string(stripe.FinancialConnectionsSessionPermissionBalances)),
  },
};
result, err := session.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

SessionCreateParams params =
  SessionCreateParams.builder()
    .setAccountHolder(
      SessionCreateParams.AccountHolder.builder()
        .setType(SessionCreateParams.AccountHolder.Type.CUSTOMER)
        .setCustomer("<<customer>>")
        .build()
    )
    .addPermission(SessionCreateParams.Permission.BALANCES)
    .build();

Session session = Session.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const session = await stripe.financialConnections.sessions.create({
  account_holder: {
    type: 'customer',
    customer: '<<customer>>',
  },
  permissions: ['balances'],
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

session = stripe.financial_connections.Session.create(
  account_holder={"type": "customer", "customer": "<<customer>>"},
  permissions=["balances"],
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$session = $stripe->financialConnections->sessions->create([
  'account_holder' => [
    'type' => 'customer',
    'customer' => '<<customer>>',
  ],
  'permissions' => ['balances'],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

session = Stripe::FinancialConnections::Session.create({
  account_holder: {
    type: 'customer',
    customer: '<<customer>>',
  },
  permissions: ['balances'],
})
```

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new Stripe.Checkout.SessionCreateOptions
{
    Customer = "<<customer>>",
    PaymentMethodTypes = new List<string> { "us_bank_account" },
    PaymentMethodOptions = new Stripe.Checkout.SessionPaymentMethodOptionsOptions
    {
        UsBankAccount = new Stripe.Checkout.SessionPaymentMethodOptionsUsBankAccountOptions
        {
            FinancialConnections = new Stripe.Checkout.SessionPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
            {
                Permissions = new List<string> { "balances", "payment_method" },
            },
        },
    },
};
var service = new Stripe.Checkout.SessionService();
Stripe.Checkout.Session session = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.CheckoutSessionParams{
  Customer: stripe.String("<<customer>>"),
  PaymentMethodTypes: []*string{stripe.String("us_bank_account")},
  PaymentMethodOptions: &stripe.CheckoutSessionPaymentMethodOptionsParams{
    USBankAccount: &stripe.CheckoutSessionPaymentMethodOptionsUSBankAccountParams{
      FinancialConnections: &stripe.CheckoutSessionPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
        Permissions: []*string{
          stripe.String(string(stripe.CheckoutSessionPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
          stripe.String(string(stripe.CheckoutSessionPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
        },
      },
    },
  },
};
result, err := session.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

SessionCreateParams params =
  SessionCreateParams.builder()
    .setCustomer("<<customer>>")
    .addPaymentMethodType(SessionCreateParams.PaymentMethodType.US_BANK_ACCOUNT)
    .setPaymentMethodOptions(
      SessionCreateParams.PaymentMethodOptions.builder()
        .setUsBankAccount(
          SessionCreateParams.PaymentMethodOptions.UsBankAccount.builder()
            .setFinancialConnections(
              SessionCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                .addPermission(
                  SessionCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                )
                .addPermission(
                  SessionCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

Session session = Session.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const session = await stripe.checkout.sessions.create({
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {
      financial_connections: {
        permissions: ['balances', 'payment_method'],
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

session = stripe.checkout.Session.create(
  customer="<<customer>>",
  payment_method_types=["us_bank_account"],
  payment_method_options={
    "us_bank_account": {"financial_connections": {"permissions": ["balances", "payment_method"]}},
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$session = $stripe->checkout->sessions->create([
  'customer' => '<<customer>>',
  'payment_method_types' => ['us_bank_account'],
  'payment_method_options' => [
    'us_bank_account' => [
      'financial_connections' => ['permissions' => ['balances', 'payment_method']],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

session = Stripe::Checkout::Session.create({
  customer: '<<customer>>',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {financial_connections: {permissions: ['balances', 'payment_method']}},
  },
})
```

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new InvoiceCreateOptions
{
    Customer = "<<customer>>",
    PaymentSettings = new InvoicePaymentSettingsOptions
    {
        PaymentMethodTypes = new List<string> { "us_bank_account" },
        PaymentMethodOptions = new InvoicePaymentSettingsPaymentMethodOptionsOptions
        {
            UsBankAccount = new InvoicePaymentSettingsPaymentMethodOptionsUsBankAccountOptions
            {
                FinancialConnections = new InvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
                {
                    Permissions = new List<string> { "balances", "payment_method" },
                },
            },
        },
    },
};
var service = new InvoiceService();
Invoice invoice = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.InvoiceParams{
  Customer: stripe.String("<<customer>>"),
  PaymentSettings: &stripe.InvoicePaymentSettingsParams{
    PaymentMethodTypes: []*string{
      stripe.String(string(stripe.InvoicePaymentSettingsPaymentMethodTypeUSBankAccount)),
    },
    PaymentMethodOptions: &stripe.InvoicePaymentSettingsPaymentMethodOptionsParams{
      USBankAccount: &stripe.InvoicePaymentSettingsPaymentMethodOptionsUSBankAccountParams{
        FinancialConnections: &stripe.InvoicePaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
          Permissions: []*string{
            stripe.String(string(stripe.InvoicePaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
            stripe.String(string(stripe.InvoicePaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
          },
        },
      },
    },
  },
};
result, err := invoice.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

InvoiceCreateParams params =
  InvoiceCreateParams.builder()
    .setCustomer("<<customer>>")
    .setPaymentSettings(
      InvoiceCreateParams.PaymentSettings.builder()
        .addPaymentMethodType(InvoiceCreateParams.PaymentSettings.PaymentMethodType.US_BANK_ACCOUNT)
        .setPaymentMethodOptions(
          InvoiceCreateParams.PaymentSettings.PaymentMethodOptions.builder()
            .setUsBankAccount(
              InvoiceCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.builder()
                .setFinancialConnections(
                  InvoiceCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                    .addPermission(
                      InvoiceCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                    )
                    .addPermission(
                      InvoiceCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                    )
                    .build()
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

Invoice invoice = Invoice.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const invoice = await stripe.invoices.create({
  customer: '<<customer>>',
  payment_settings: {
    payment_method_types: ['us_bank_account'],
    payment_method_options: {
      us_bank_account: {
        financial_connections: {
          permissions: ['balances', 'payment_method'],
        },
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

invoice = stripe.Invoice.create(
  customer="<<customer>>",
  payment_settings={
    "payment_method_types": ["us_bank_account"],
    "payment_method_options": {
      "us_bank_account": {"financial_connections": {"permissions": ["balances", "payment_method"]}},
    },
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$invoice = $stripe->invoices->create([
  'customer' => '<<customer>>',
  'payment_settings' => [
    'payment_method_types' => ['us_bank_account'],
    'payment_method_options' => [
      'us_bank_account' => [
        'financial_connections' => ['permissions' => ['balances', 'payment_method']],
      ],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

invoice = Stripe::Invoice.create({
  customer: '<<customer>>',
  payment_settings: {
    payment_method_types: ['us_bank_account'],
    payment_method_options: {
      us_bank_account: {financial_connections: {permissions: ['balances', 'payment_method']}},
    },
  },
})
```

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new SubscriptionCreateOptions
{
    Customer = "{{CUSTOMER_ID}}",
    PaymentSettings = new SubscriptionPaymentSettingsOptions
    {
        PaymentMethodTypes = new List<string> { "us_bank_account" },
        PaymentMethodOptions = new SubscriptionPaymentSettingsPaymentMethodOptionsOptions
        {
            UsBankAccount = new SubscriptionPaymentSettingsPaymentMethodOptionsUsBankAccountOptions
            {
                FinancialConnections = new SubscriptionPaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
                {
                    Permissions = new List<string> { "balances", "payment_method" },
                },
            },
        },
    },
};
var service = new SubscriptionService();
Subscription subscription = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.SubscriptionParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  PaymentSettings: &stripe.SubscriptionPaymentSettingsParams{
    PaymentMethodTypes: []*string{
      stripe.String(string(stripe.SubscriptionPaymentSettingsPaymentMethodTypeUSBankAccount)),
    },
    PaymentMethodOptions: &stripe.SubscriptionPaymentSettingsPaymentMethodOptionsParams{
      USBankAccount: &stripe.SubscriptionPaymentSettingsPaymentMethodOptionsUSBankAccountParams{
        FinancialConnections: &stripe.SubscriptionPaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
          Permissions: []*string{
            stripe.String(string(stripe.SubscriptionPaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
            stripe.String(string(stripe.SubscriptionPaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
          },
        },
      },
    },
  },
};
result, err := subscription.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

SubscriptionCreateParams params =
  SubscriptionCreateParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .setPaymentSettings(
      SubscriptionCreateParams.PaymentSettings.builder()
        .addPaymentMethodType(
          SubscriptionCreateParams.PaymentSettings.PaymentMethodType.US_BANK_ACCOUNT
        )
        .setPaymentMethodOptions(
          SubscriptionCreateParams.PaymentSettings.PaymentMethodOptions.builder()
            .setUsBankAccount(
              SubscriptionCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.builder()
                .setFinancialConnections(
                  SubscriptionCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                    .addPermission(
                      SubscriptionCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                    )
                    .addPermission(
                      SubscriptionCreateParams.PaymentSettings.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                    )
                    .build()
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

Subscription subscription = Subscription.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const subscription = await stripe.subscriptions.create({
  customer: '{{CUSTOMER_ID}}',
  payment_settings: {
    payment_method_types: ['us_bank_account'],
    payment_method_options: {
      us_bank_account: {
        financial_connections: {
          permissions: ['balances', 'payment_method'],
        },
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

subscription = stripe.Subscription.create(
  customer="{{CUSTOMER_ID}}",
  payment_settings={
    "payment_method_types": ["us_bank_account"],
    "payment_method_options": {
      "us_bank_account": {"financial_connections": {"permissions": ["balances", "payment_method"]}},
    },
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$subscription = $stripe->subscriptions->create([
  'customer' => '{{CUSTOMER_ID}}',
  'payment_settings' => [
    'payment_method_types' => ['us_bank_account'],
    'payment_method_options' => [
      'us_bank_account' => [
        'financial_connections' => ['permissions' => ['balances', 'payment_method']],
      ],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

subscription = Stripe::Subscription.create({
  customer: '{{CUSTOMER_ID}}',
  payment_settings: {
    payment_method_types: ['us_bank_account'],
    payment_method_options: {
      us_bank_account: {financial_connections: {permissions: ['balances', 'payment_method']}},
    },
  },
})
```

When using dynamic payment methods for certain payments APIs, you can also configure requested permissions in the Dashboard. Learn how to [access additional account data on Financial Connections accounts](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md?dashboard-or-api=dashboard#access).

## Initiate a balance refresh

All Financial Connections data retrievals are asynchronous. You initiate a balance refresh and wait for it to complete, then retrieve the results. You can initiate balance refreshes with the `prefetch` API parameter or the [Refresh API](https://docs.stripe.com/api/financial_connections/accounts/refresh.md).

### Prefetch balance data

Specify whether you want to prefetch account balances _before_ account collection. This initiates the refresh process as soon as your user connects their account in the [authentication flow](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow). Set `prefetch` when you require balance data for every linked account, to make sure you receive it with minimal delay. An example of this is if you plan to perform balance checks prior to initiating an ACH payment. The `prefetch` parameter is available on all APIs that support Financial Connections.

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new PaymentIntentCreateOptions
{
    Amount = 20000,
    Currency = "usd",
    PaymentMethodTypes = new List<string> { "us_bank_account" },
    PaymentMethodOptions = new PaymentIntentPaymentMethodOptionsOptions
    {
        UsBankAccount = new PaymentIntentPaymentMethodOptionsUsBankAccountOptions
        {
            FinancialConnections = new PaymentIntentPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
            {
                Prefetch = new List<string> { "balances" },
                Permissions = new List<string> { "payment_method", "balances" },
            },
        },
    },
};
var service = new PaymentIntentService();
PaymentIntent paymentIntent = service.Create(options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(20000),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  PaymentMethodTypes: []*string{stripe.String("us_bank_account")},
  PaymentMethodOptions: &stripe.PaymentIntentPaymentMethodOptionsParams{
    USBankAccount: &stripe.PaymentIntentPaymentMethodOptionsUSBankAccountParams{
      FinancialConnections: &stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsParams{
        Prefetch: []*string{
          stripe.String(string(stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPrefetchBalances)),
        },
        Permissions: []*string{
          stripe.String(string(stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionPaymentMethod)),
          stripe.String(string(stripe.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionBalances)),
        },
      },
    },
  },
};
result, err := paymentintent.New(params);
```

```java
Stripe.apiKey = "<<secret key>>";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setAmount(20000L)
    .setCurrency("usd")
    .addPaymentMethodType("us_bank_account")
    .setPaymentMethodOptions(
      PaymentIntentCreateParams.PaymentMethodOptions.builder()
        .setUsBankAccount(
          PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.builder()
            .setFinancialConnections(
              PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.builder()
                .addPrefetch(
                  PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Prefetch.BALANCES
                )
                .addPermission(
                  PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.PAYMENT_METHOD
                )
                .addPermission(
                  PaymentIntentCreateParams.PaymentMethodOptions.UsBankAccount.FinancialConnections.Permission.BALANCES
                )
                .build()
            )
            .build()
        )
        .build()
    )
    .build();

PaymentIntent paymentIntent = PaymentIntent.create(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const paymentIntent = await stripe.paymentIntents.create({
  amount: 20000,
  currency: 'usd',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {
      financial_connections: {
        prefetch: ['balances'],
        permissions: ['payment_method', 'balances'],
      },
    },
  },
});
```

```python
import stripe
stripe.api_key = "<<secret key>>"

payment_intent = stripe.PaymentIntent.create(
  amount=20000,
  currency="usd",
  payment_method_types=["us_bank_account"],
  payment_method_options={
    "us_bank_account": {
      "financial_connections": {
        "prefetch": ["balances"],
        "permissions": ["payment_method", "balances"],
      },
    },
  },
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$paymentIntent = $stripe->paymentIntents->create([
  'amount' => 20000,
  'currency' => 'usd',
  'payment_method_types' => ['us_bank_account'],
  'payment_method_options' => [
    'us_bank_account' => [
      'financial_connections' => [
        'prefetch' => ['balances'],
        'permissions' => ['payment_method', 'balances'],
      ],
    ],
  ],
]);
```

```ruby
Stripe.api_key = '<<secret key>>'

payment_intent = Stripe::PaymentIntent.create({
  amount: 20000,
  currency: 'usd',
  payment_method_types: ['us_bank_account'],
  payment_method_options: {
    us_bank_account: {
      financial_connections: {
        prefetch: ['balances'],
        permissions: ['payment_method', 'balances'],
      },
    },
  },
})
```

### Initiate an on-demand refresh

Use the [Refresh API](https://docs.stripe.com/api/financial_connections/accounts/refresh.md) to initiate on-demand balance refreshes _after_ account collection, and fetch balance information for a specific account at your convenience, allowing you to defer the decision until a later time.

Use the Financial Connections account ID to initiate a refresh. If you’re integrating through a payments flow, find the account ID [on the associated Payment Method](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#finding-the-financial-connections-account-id). When using a Financial Connections Session, retrieve it [through the session](https://docs.stripe.com/financial-connections/other-data-powered-products.md?platform=web#collect-an-account).

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var options = new Stripe.FinancialConnections.AccountRefreshOptions
{
    Features = new List<string> { "balance" },
};
var service = new Stripe.FinancialConnections.AccountService();
Stripe.FinancialConnections.Account account = service.Refresh(
    "<<financialConnectionsAccount>>",
    options);
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.FinancialConnectionsAccountRefreshParams{
  Features: []*string{stripe.String("balance")},
};
result, err := account.Refresh("<<financialConnectionsAccount>>", params);
```

```java
Stripe.apiKey = "<<secret key>>";

Account resource = Account.retrieve("<<financialConnectionsAccount>>");

AccountRefreshParams params =
  AccountRefreshParams.builder().addFeature(AccountRefreshParams.Feature.BALANCE).build();

Account account = resource.refresh(params);
```

```node
const stripe = require('stripe')('<<secret key>>');

const account = await stripe.financialConnections.accounts.refresh(
  '<<financialConnectionsAccount>>',
  {
    features: ['balance'],
  }
);
```

```python
import stripe
stripe.api_key = "<<secret key>>"

account = stripe.financial_connections.Account.refresh_account(
  "<<financialConnectionsAccount>>",
  features=["balance"],
)
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$account = $stripe->financialConnections->accounts->refresh(
  '<<financialConnectionsAccount>>',
  ['features' => ['balance']]
);
```

```ruby
Stripe.api_key = '<<secret key>>'

account = Stripe::FinancialConnections::Account.refresh_account(
  '<<financialConnectionsAccount>>',
  {features: ['balance']},
)
```

### Wait for the balance refresh to complete

The [balance_refresh](https://docs.stripe.com/api/financial_connections/accounts/object.md#financial_connections_account_object-balance_refresh) field on a Financial Connections account represents the balance refresh state. This field remains `null` until you request the `balances` permission and initiate a refresh. After you start a balance refresh, the state changes to `pending`, and after completion, it moves to either `succeeded` or `failed`. We send the [financial_connections.account.refreshed_balance](https://docs.stripe.com/api/events/types.md#event_types-financial_connections.account.refreshed_balance) event when the balance refresh completes. To determine the success of the refresh, check the `balance_refresh.status` field while handling the webhook.

After a balance refresh completes, Stripe sets the availability of future refreshes through the [balance_refresh.next_refresh_available_at](https://docs.stripe.com/api/financial_connections/accounts/object.md#financial_connections_account_object-balance_refresh-next_refresh_available_at) field. 

## Retrieve an account's balances

After the balance refresh has completed, retrieve the Financial Connections Account from the body of the
[financial_connections.account.refreshed_balance](https://docs.stripe.com/api/events/types.md#event_types-financial_connections.account.refreshed_balance) event
or through the API.

```dotnet
StripeConfiguration.ApiKey = "<<secret key>>";

var service = new Stripe.FinancialConnections.AccountService();
Stripe.FinancialConnections.Account account = service.Get("<<financialConnectionsAccount>>");
```

```go
stripe.Key = "<<secret key>>"

params := &stripe.FinancialConnectionsAccountParams{};
result, err := account.GetByID("<<financialConnectionsAccount>>", params);
```

```java
Stripe.apiKey = "<<secret key>>";

Account account = Account.retrieve("<<financialConnectionsAccount>>");
```

```node
const stripe = require('stripe')('<<secret key>>');

const account = await stripe.financialConnections.accounts.retrieve(
  '<<financialConnectionsAccount>>'
);
```

```python
import stripe
stripe.api_key = "<<secret key>>"

account = stripe.financial_connections.Account.retrieve("<<financialConnectionsAccount>>")
```

```php
$stripe = new \Stripe\StripeClient('<<secret key>>');

$account = $stripe->financialConnections->accounts->retrieve('<<financialConnectionsAccount>>', []);
```

```ruby
Stripe.api_key = '<<secret key>>'

account = Stripe::FinancialConnections::Account.retrieve('<<financialConnectionsAccount>>')
```

If the refresh completed successfully, the account object contains balance data.

```json
{
  "id": "fca_1Jbry3BAjqvGMUSxCDjFsrLU",
  "object": "financial_connections.account",
  "balance": {
    "as_of": 1651516592,
    "cash": {
      "available": {
        "usd": 6000
      }
    },
    "current": {
      "usd": 6000
    },
    "type": "cash"
  },
  "balance_refresh": {
    "last_attempted_at": 1651516582,
    "next_refresh_available_at": 1651516583,
    "status": "succeeded",
  },
  // ... other fields on the Financial Connections Account
}
```

#### Balance data details

The `balance` hash describes the different types of balances made available by a financial institution.

| Balance Types | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `current`     | The `current` balance is the amount of funds that have posted to the account. This amount ignores events that have yet to post to an account such as incoming transfers, outgoing transfers, and other holds. A positive amount indicates money owed to the account holder. A negative amount indicates money owed by the account holder.                                                                                                                                                                                                             |
| `available`   | The balance object is polymorphic, with types `cash` and `credit`. If the balance has `type: "cash"`, you’ll see a `cash` sub-object with the `available` property, which is the amount of funds available for use, such as any to be transferred or paid out, after considering incoming and outgoing holds.                                                                                                                                                                                                                                         |
| `used`        | The balance object is polymorphic, with types `cash` and `credit`. If the balance has `type: "credit"`, you’ll see a `credit` sub-object with the `used` property, which is the amount of funds that have been consumed after taking outgoing holds into account. For credit balances, `current` and `used` amounts use the same sign convention used for cash balances: a positive amount means funds owed _to_ the account holder, a negative amount means funds owed _by_ the account holder. In most cases a credit balance has negative amounts. |

The availability of balances varies by underlying financial institution. We return all balance data that we have access to. In rare cases, most often when dealing with smaller financial institutions, Stripe can’t retrieve balance data from a financial institution or partner of any kind, in which case the `balance` object is `null`. The balance object is also `null` if the account has been disconnected. In some instances only a `current` balance is returned. See our list of [supported institutions](https://docs.stripe.com/financial-connections/supported-institutions.md) for data coverage.

For the `cash` balance type, use the `available` sub-object to confirm sufficient funds exist prior to initiating an ACH Direct Debit payment. If an `available` balance is null, you might want to use the `current` balance to confirm sufficient funds prior to initiating an ACH Direct Debit, but be mindful that this amount ignores events that have yet to post to an account such as incoming transfers, outgoing transfers, and other holds.

The `as_of` field on a balance is the date and time that the financial institution calculated this balance. This isn’t the same as the date and time of balance data retrieval. For example, certain institutions only update balance data once per day, while others update more frequently.