# Access ownership details for a Financial Connections account

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

The Financial Connections API allows you to retrieve the ownership details of a [Financial Connections account](https://docs.stripe.com/api/financial_connections/accounts/object.md). Ownership data is useful for a variety of applications, including reducing the risk of fraud when onboarding users or underwriting.

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 ownership data

You must collect an account before you can access its ownership data. To learn more about how to collect Financial Connections Accounts, read the integration guide most relevant to your use case (for example, [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)).

If you use [Connect Onboarding for Custom Accounts](https://docs.stripe.com/connect/payouts-bank-accounts.md?bank-account-collection-integration=prebuilt-web-form) to collect Financial Connections Accounts, configure which data you want access to in the [Dashboard](https://dashboard.stripe.com/settings/connect/custom).

If you use an API integration to collect accounts, 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 SetupIntentCreateOptions
{
    Customer = "<<customer>>",
    PaymentMethodTypes = new List<string> { "us_bank_account" },
    PaymentMethodOptions = new SetupIntentPaymentMethodOptionsOptions
    {
        UsBankAccount = new SetupIntentPaymentMethodOptionsUsBankAccountOptions
        {
            FinancialConnections = new SetupIntentPaymentMethodOptionsUsBankAccountFinancialConnectionsOptions
            {
                Permissions = new List<string> { "ownership", "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.SetupIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionOwnership)),
          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.OWNERSHIP
                )
                .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: ['ownership', '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": ["ownership", "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' => ['ownership', '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: ['ownership', 'payment_method']}},
  },
})
```

```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> { "ownership", "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.PaymentIntentPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionOwnership)),
          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.OWNERSHIP
                )
                .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: ['ownership', '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": ["ownership", "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' => ['ownership', '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: ['ownership', '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> { "ownership" },
};
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.FinancialConnectionsSessionPermissionOwnership)),
  },
};
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.OWNERSHIP)
    .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: ['ownership'],
});
```

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

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

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

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

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

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

```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> { "ownership", "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.CheckoutSessionPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionOwnership)),
          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.OWNERSHIP
                )
                .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: ['ownership', '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": ["ownership", "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' => ['ownership', '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: ['ownership', '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> { "ownership", "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.InvoicePaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionOwnership)),
            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.OWNERSHIP
                    )
                    .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: ['ownership', '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": ["ownership", "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' => ['ownership', '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: ['ownership', '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> { "ownership", "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.SubscriptionPaymentSettingsPaymentMethodOptionsUSBankAccountFinancialConnectionsPermissionOwnership)),
            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.OWNERSHIP
                    )
                    .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: ['ownership', '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": ["ownership", "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' => ['ownership', '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: ['ownership', '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 an ownership refresh

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

### Prefetch ownership data

Specify whether you want to prefetch account ownership details _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 ownership data for every linked account, to make sure you receive it with minimal delay. The `prefetch` parameter is available on all APIs that support Financial Connections.

### Initiate an on-demand refresh

Use the [Refresh API](https://docs.stripe.com/api/financial_connections/accounts/refresh.md) to initiate on-demand ownership refreshes _after_ account collection, and fetch ownership information for a specific account at your convenience, allowing you to defer the decision until a later time. Although account ownership data can change, it generally doesn’t change as frequently as [balance](https://docs.stripe.com/financial-connections/balances.md) or [transaction](https://docs.stripe.com/financial-connections/transactions.md) data.

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> { "ownership" },
};
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("ownership")},
};
result, err := account.Refresh("<<financialConnectionsAccount>>", params);
```

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

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

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

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

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

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

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

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

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

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

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

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

### Wait for the ownership refresh to complete

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

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

## Retrieve an account's ownership data

After the ownership refresh completes, retrieve the Financial Connections account from the API and expand the [ownership](https://docs.stripe.com/api/financial_connections/accounts/object.md#financial_connections_account_object-ownership) field to see ownership details.

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

var options = new Stripe.FinancialConnections.AccountGetOptions
{
    Expand = new List<string> { "ownership" },
};
var service = new Stripe.FinancialConnections.AccountService();
Stripe.FinancialConnections.Account account = service.Get(
    "<<financialConnectionsAccount>>",
    options);
```

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

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

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

AccountRetrieveParams params = AccountRetrieveParams.builder().addExpand("ownership").build();

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

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

const account = await stripe.financialConnections.accounts.retrieve(
  '<<financialConnectionsAccount>>',
  {
    expand: ['ownership'],
  }
);
```

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

account = stripe.financial_connections.Account.retrieve(
  "<<financialConnectionsAccount>>",
  expand=["ownership"],
)
```

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

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

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

account = Stripe::FinancialConnections::Account.retrieve({
  expand: ['ownership'],
  id: '<<financialConnectionsAccount>>',
})
```

This returns the Financial Connections account with the ownership field expanded to list the account’s owners:

```json
{
  "id": "fca_zbyrdjTrwcYZJZc6WBs6GPid",
  "object": "financial_connections.account",
  "ownership": {
    "id": "fcaowns_1MzTG4IG1CZuezXppfPbUpXb",
    "object": "financial_connections.account_ownership",
    "created": 1651784999,
    "owners": {
      "object": "list",
      "data": [
        {
          "name": "Jenny Rosen",
          "email": "jenny.rosen@example.com",
          "phone": "+1 555-555-5555",
          "ownership": "fcaowns_1MzTG4IG1CZuezXppfPbUpXb",
          "raw_address": "510 Townsend San Francisco, CA 94103",
          "refreshed_at": 1651784999
        }
      ],
      "has_more": false,
      "url": "/v1/financial_connections/accounts/fca_zbyrdjTrwcYZJZc6WBs6GPid/owners?ownership=fcaowns_1MzTG4IG1CZuezXppfPbUpXb"
    }
  },
  "ownership_refresh": {
    "status": "succeeded",
    "last_attempted_at": 1651784999,
    "next_refresh_available_at": 1651785000
  },
  // ...
}
```

Stripe returns the ownership information made available by a financial institution, and the availability of ownership details varies. We return all available fields and owners provided by the bank. Ownership details can include account owner name, address, email, and phone number.