---
title: Working with connected accounts in Treasury
subtitle: >-
  Request the Treasury capability and collect onboarding requirements for your
  connected accounts.
route: /treasury/account-management/connected-accounts

---

# Working with connected accounts in Treasury

Request the Treasury capability and collect onboarding requirements for your connected accounts.

To use Stripe *Treasury* (A collection of API endpoints and cloud- and web-based features that enable platforms to offer embedded financial solutions to their users), your platform must have a Stripe *Connect* (Connect is Stripe's solution for multi-party businesses, such as marketplace or software platforms, to route payments between sellers, customers, and other recipients) integration. Stripe Connect enables a platform to provide connected accounts to sellers and service providers. For an overview of how connected accounts fit into the Stripe Treasury account structure, see the [Stripe Treasury accounts structure](https://stripe.com/treasury/account-management/treasury-accounts-structure) guide.

Treasury only supports connected accounts that don’t use a Stripe-hosted dashboard and where your platform is responsible for requirements collection and loss liability, including Custom connected accounts. Learn how to [create connected accounts](https://stripe.com/connect/design-an-integration?connect-onboarding-surface=api&connect-dashboard-type=none&connect-economic-model=buy-rate&connect-loss-liability-owner=platform&connect-charge-type=direct) that work with Treasury.

Enabling Treasury on non-custom connected accounts is a new feature. Email [treasury-support@stripe.com](mailto:treasury-support@stripe.com) to request access.

As a platform with connected accounts, you’re responsible for maintaining a minimum API version, communicating terms of service updates to your connected accounts, handling information requests from them, and providing them with support. Because your platform is ultimately responsible for the losses your connected accounts incur, you’re also responsible for vetting them for fraud. To learn more, read the [Treasury fraud guide](https://stripe.com/treasury/examples/fraud-guide).

Connected accounts require specific capabilities enabled on the account to use features of Treasury. Different features require different capabilities, which might require additional information about your connected account owners. The `treasury` capability, for example, is a requirement on connected accounts for Treasury access. When you request `treasury` for an account, additional fields become required for that connected account before the account can use Treasury.

Before you create connected accounts in live mode for your Treasury integration, we recommend you first create test connected accounts in a *sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes) environment. Test connected accounts can’t receive or send real money and can’t be used in live mode, but are otherwise identical in configuration and functionality.

## Checking current connected account types

If your platform already has a Connect integration with connected accounts but are unsure of their type, you can use the Dashboard or API to retrieve this information.

#### Dashboard

Navigate to the [Connected accounts page](https://dashboard.stripe.com/test/connect/accounts/overview) in the Dashboard. We list your connected accounts in a table format.
![Table of connected accounts](https://b.stripecdn.com/docs-statics-srv/assets/account-dashboard.f7c91e5c9e06a1ca68102ed2cbaaa8ce.png)

Connected accounts

To find the account features, select an account in the table to open the detailed view, then click **Profile** > **Account information**.
![Account details section of the dashboard displaying one account of type Custom.](https://b.stripecdn.com/docs-statics-srv/assets/account-information.22a76ce6f2d50771ebd78a0f21020fb3.png)

Account information

#### API request

Use `GET /v1/accounts` to retrieve a list of the accounts on your platform.

```json
{
  "object": "list",
  "data": [
    {
      "id": "acct_1KUbgB2E0Hr5XQiY",
      "object": "account",
      "controller": {
        "type": "application",
        "dashboard": {
          "type": "none"
        },
        "losses": {
          "payments": "application"
        },
        "requirement_collection": "application",
        "fees": {
          "payer": "application"
        },
      },
      ...
    }
  ]
}
```

## Create a new connected account with the treasury capability

This guide demonstrates how to create a new connected account using the Stripe API for Treasury and isn’t exhaustive. For complete documentation on creating a connected account, including through hosted onboarding, see the [Connect integration guide](https://stripe.com/connect/design-an-integration?connect-onboarding-surface=api&connect-dashboard-type=none&connect-economic-model=buy-rate&connect-loss-liability-owner=platform&connect-charge-type=direct).

Use `POST /v1/accounts` to create a new connected account. Request the following capabilities for the account, which are required to use Stripe Treasury:

- `transfers` (required for all connected accounts)
- `treasury`

You can update the account later to request these capabilities if you don’t do so when creating the account.

If you want to issue cards with Stripe Issuing to your connected account, you must request the `card_issuing` capability, as well. See the [Working with Stripe Issuing cards](https://stripe.com/treasury/account-management/issuing-cards) guide for more information.

If you want to use ACH to transfer funds to or from an external account, you must also request the `us_bank_account_ach_payments` capability.

With all the previous options included, the request resembles the following:

```javascript
const account = await stripe.accounts.create({
  country: 'US',
  email: email,
  capabilities: {
    transfers: {requested: true},
    treasury: {requested: true},
    card_issuing: {requested: true},
  },
  controller: {
    dashboard: {type: "none"},
    losses: {payments: "application"},
    requirement_collection: "application",
    fees: {payer: "application"}
  },
});
```

If successful, the response you receive confirms the connected account and requested `capabilities`.

```json
{
  "id": "acct_1234",
  "object": "account",
  "capabilities": {
    "card_issuing": "inactive", // Should be requested only for Stripe Issuing users.
    "treasury": "inactive",
    "us_bank_account_ach_payments": "inactive"
  },
  ...
}
```

To learn more about connected account capabilities, see the [Account capabilities](https://stripe.com/connect/account-capabilities) guide for Connect.

## Update a connected account to include the treasury capability

If you already have a connected account with `card_payments` enabled, use `POST /v1/accounts/{{CONNECTED_ACCOUNT_ID}}` to update the account with the associated ID with a request for the `treasury` capability. The following request updates a connected account with a request for the `treasury` capability, and includes the optional capabilities of `card_issuing` and `us_bank_account_ach_payments`:
Code snippet calling post /v1/accounts/{id} in curl (resource-based pattern).
```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTEDACCOUNT_ID}} \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d "capabilities[treasury][requested]"=true \
  -d "capabilities[card_issuing][requested]"=true \
  -d "capabilities[us_bank_account_ach_payments][requested]"=true
```
Code snippet calling post /v1/accounts/{id} in cli (resource-based pattern).
```cli
stripe accounts update {{CONNECTEDACCOUNT_ID}} \
  -d "capabilities[treasury][requested]"=true \
  -d "capabilities[card_issuing][requested]"=true \
  -d "capabilities[us_bank_account_ach_payments][requested]"=true
```
Code snippet calling post /v1/accounts/{id} in ruby (resource-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

account = Stripe::Account.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    capabilities: {
      treasury: {requested: true},
      card_issuing: {requested: true},
      us_bank_account_ach_payments: {requested: true},
    },
  },
)
```
Code snippet calling post /v1/accounts/{id} in ruby (service-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.v1.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    capabilities: {
      treasury: {requested: true},
      card_issuing: {requested: true},
      us_bank_account_ach_payments: {requested: true},
    },
  },
)
```
Code snippet calling post /v1/accounts/{id} in python (resource-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
import stripe
stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

account = stripe.Account.modify(
  "{{CONNECTEDACCOUNT_ID}}",
  capabilities={
    "treasury": {"requested": True},
    "card_issuing": {"requested": True},
    "us_bank_account_ach_payments": {"requested": True},
  },
)
```
Code snippet calling post /v1/accounts/{id} in python (service-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.accounts.update(
  "{{CONNECTEDACCOUNT_ID}}",
  {
    "capabilities": {
      "treasury": {"requested": True},
      "card_issuing": {"requested": True},
      "us_bank_account_ach_payments": {"requested": True},
    },
  },
)
```
Code snippet calling post /v1/accounts/{id} in php (resource-based pattern).
```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

$account = $stripe->accounts->update(
  '{{CONNECTEDACCOUNT_ID}}',
  [
    'capabilities' => [
      'treasury' => ['requested' => true],
      'card_issuing' => ['requested' => true],
      'us_bank_account_ach_payments' => ['requested' => true],
    ],
  ]
);
```
Code snippet calling post /v1/accounts/{id} in java (resource-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

Account resource = Account.retrieve("{{CONNECTEDACCOUNT_ID}}");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setCapabilities(
      AccountUpdateParams.Capabilities.builder()
        .setCardIssuing(
          AccountUpdateParams.Capabilities.CardIssuing.builder()
            .setRequested(true)
            .build()
        )
        .setUsBankAccountAchPayments(
          AccountUpdateParams.Capabilities.UsBankAccountAchPayments.builder()
            .setRequested(true)
            .build()
        )
        .build()
    )
    .putExtraParam("capabilities[treasury][requested]", true)
    .build();

Account account = resource.update(params);
```
Code snippet calling post /v1/accounts/{id} in java (service-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setCapabilities(
      AccountUpdateParams.Capabilities.builder()
        .setCardIssuing(
          AccountUpdateParams.Capabilities.CardIssuing.builder()
            .setRequested(true)
            .build()
        )
        .setUsBankAccountAchPayments(
          AccountUpdateParams.Capabilities.UsBankAccountAchPayments.builder()
            .setRequested(true)
            .build()
        )
        .build()
    )
    .putExtraParam("capabilities[treasury][requested]", true)
    .build();

Account account = client.accounts().update("{{CONNECTEDACCOUNT_ID}}", params);
```
Code snippet calling post /v1/accounts/{id} in node (resource-based pattern).
```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

const account = await stripe.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    capabilities: {
      treasury: {
        requested: true,
      },
      card_issuing: {
        requested: true,
      },
      us_bank_account_ach_payments: {
        requested: true,
      },
    },
  }
);
```
Code snippet calling post /v1/accounts/{id} in go (resource-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
stripe.Key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

params := &stripe.AccountParams{
  Capabilities: &stripe.AccountCapabilitiesParams{
    CardIssuing: &stripe.AccountCapabilitiesCardIssuingParams{
      Requested: stripe.Bool(true),
    },
    USBankAccountACHPayments: &stripe.AccountCapabilitiesUSBankAccountACHPaymentsParams{
      Requested: stripe.Bool(true),
    },
  },
};
params.AddExtra("capabilities[treasury][requested]", true)
result, err := account.Update("{{CONNECTEDACCOUNT_ID}}", params);
```
Code snippet calling post /v1/accounts/{id} in go (service-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys

sc := stripe.NewClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
params := &stripe.AccountUpdateParams{
  Capabilities: &stripe.AccountUpdateCapabilitiesParams{
    CardIssuing: &stripe.AccountUpdateCapabilitiesCardIssuingParams{
      Requested: stripe.Bool(true),
    },
    USBankAccountACHPayments: &stripe.AccountUpdateCapabilitiesUSBankAccountACHPaymentsParams{
      Requested: stripe.Bool(true),
    },
  },
  Account: stripe.String("{{CONNECTEDACCOUNT_ID}}"),
};
params.AddExtra("capabilities[treasury][requested]", true)
result, err := sc.V1Accounts.Update(context.TODO(), params);
```
Code snippet calling post /v1/accounts/{id} in dotnet (resource-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeConfiguration.ApiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

var options = new AccountUpdateOptions
{
    Capabilities = new AccountCapabilitiesOptions
    {
        Treasury = new AccountCapabilitiesTreasuryOptions { Requested = true },
        CardIssuing = new AccountCapabilitiesCardIssuingOptions { Requested = true },
        UsBankAccountAchPayments = new AccountCapabilitiesUsBankAccountAchPaymentsOptions
        {
            Requested = true,
        },
    },
};
var service = new AccountService();
Account account = service.Update("{{CONNECTEDACCOUNT_ID}}", options);
```
Code snippet calling post /v1/accounts/{id} in dotnet (service-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new AccountUpdateOptions
{
    Capabilities = new AccountCapabilitiesOptions
    {
        Treasury = new AccountCapabilitiesTreasuryOptions { Requested = true },
        CardIssuing = new AccountCapabilitiesCardIssuingOptions { Requested = true },
        UsBankAccountAchPayments = new AccountCapabilitiesUsBankAccountAchPaymentsOptions
        {
            Requested = true,
        },
    },
};
var client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
var service = client.V1.Accounts;
Account account = service.Update("{{CONNECTEDACCOUNT_ID}}", options);
```

Use `POST /v1/accounts/{{CONNECTED_ACCOUNT_ID}}` to update connected account capabilities for connected accounts that already have a `FinancialAccount` assigned. See [Working with financial accounts](https://stripe.com/treasury/account-management/financial-accounts) or the [FinancialAccount object](https://stripe.com/api/treasury/financial_accounts/object) API documentation for more information.

## Onboard the connected account

After you create an account, you must onboard the seller or service provider to the account for ownership. The [Account](https://stripe.com/api/accounts/object#account_object-requirements-currently_due) object that represents the connected account has a `requirements` hash that contains `currently_due` [identity verification](https://stripe.com/connect/handling-api-verification) requirements. The seller or service provider on your platform must provide the details itemized in the `requirements` hash to enable charges and [payouts](https://stripe.com/payouts) on their connected account and enable all requested features of their financial account.

You have two options for onboarding connected account owners to Treasury: [hosted onboarding](https://stripe.com/treasury/account-management/connected-accounts#using-hosted-onboarding) and [custom onboarding](https://stripe.com/treasury/account-management/connected-accounts#using-custom-onboarding). We recommend hosted onboarding.

If you create a test `Account` object and want to bypass onboarding requirements to test functionality, use `POST /v1/accounts/{{CONNECTED_ACCOUNT_ID}}` to [provide test values](https://stripe.com/connect/testing-verification) that fulfill all the requirements. The following request uses a previously created connected account to apply the required account details.
Code snippet calling post /v1/accounts/{cid} in curl (resource-based pattern).
```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTED_ACCOUNT_ID}} \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d "tos_acceptance[date]"=1547923073 \
  -d "tos_acceptance[ip]"="172.18.80.19" \
  -d "settings[treasury][tos_acceptance][date]"=1547923073 \
  -d "settings[treasury][tos_acceptance][ip]"="172.18.80.19" \
  -d "business_profile[mcc]"=5045 \
  --data-urlencode "business_profile[url]"="https://bestcookieco.com" \
  -d "company[address][city]"=Schenectady \
  -d "company[address][line1]"="123 State St" \
  -d "company[address][postal_code]"=12345 \
  -d "company[address][state]"=NY \
  -d "company[tax_id]"=000000000 \
  -d "company[name]"="The Best Cookie Co" \
  -d "company[phone]"=8888675309 \
  -d "individual[first_name]"=Jenny \
  -d "individual[last_name]"=Rosen
```
Code snippet calling post /v1/accounts/{cid} in cli (resource-based pattern).
```cli
stripe accounts update {{CONNECTED_ACCOUNT_ID}} \
  -d "tos_acceptance[date]"=1547923073 \
  -d "tos_acceptance[ip]"="172.18.80.19" \
  -d "settings[treasury][tos_acceptance][date]"=1547923073 \
  -d "settings[treasury][tos_acceptance][ip]"="172.18.80.19" \
  -d "business_profile[mcc]"=5045 \
  -d "business_profile[url]"="https://bestcookieco.com" \
  -d "company[address][city]"=Schenectady \
  -d "company[address][line1]"="123 State St" \
  -d "company[address][postal_code]"=12345 \
  -d "company[address][state]"=NY \
  -d "company[tax_id]"=000000000 \
  -d "company[name]"="The Best Cookie Co" \
  -d "company[phone]"=8888675309 \
  -d "individual[first_name]"=Jenny \
  -d "individual[last_name]"=Rosen
```
Code snippet calling post /v1/accounts/{cid} in ruby (resource-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

account = Stripe::Account.update(
  '{{CONNECTED_ACCOUNT_ID}}',
  {
    tos_acceptance: {
      date: 1547923073,
      ip: '172.18.80.19',
    },
    settings: {
      treasury: {
        tos_acceptance: {
          date: 1547923073,
          ip: '172.18.80.19',
        },
      },
    },
    business_profile: {
      mcc: '5045',
      url: 'https://bestcookieco.com',
    },
    company: {
      address: {
        city: 'Schenectady',
        line1: '123 State St',
        postal_code: '12345',
        state: 'NY',
      },
      tax_id: '000000000',
      name: 'The Best Cookie Co',
      phone: '8888675309',
    },
    individual: {
      first_name: 'Jenny',
      last_name: 'Rosen',
    },
  },
)
```
Code snippet calling post /v1/accounts/{cid} in ruby (service-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.v1.accounts.update(
  '{{CONNECTED_ACCOUNT_ID}}',
  {
    tos_acceptance: {
      date: 1547923073,
      ip: '172.18.80.19',
    },
    settings: {
      treasury: {
        tos_acceptance: {
          date: 1547923073,
          ip: '172.18.80.19',
        },
      },
    },
    business_profile: {
      mcc: '5045',
      url: 'https://bestcookieco.com',
    },
    company: {
      address: {
        city: 'Schenectady',
        line1: '123 State St',
        postal_code: '12345',
        state: 'NY',
      },
      tax_id: '000000000',
      name: 'The Best Cookie Co',
      phone: '8888675309',
    },
    individual: {
      first_name: 'Jenny',
      last_name: 'Rosen',
    },
  },
)
```
Code snippet calling post /v1/accounts/{cid} in python (resource-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
import stripe
stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

account = stripe.Account.modify(
  "{{CONNECTED_ACCOUNT_ID}}",
  tos_acceptance={"date": 1547923073, "ip": "172.18.80.19"},
  settings={"treasury": {"tos_acceptance": {"date": 1547923073, "ip": "172.18.80.19"}}},
  business_profile={"mcc": "5045", "url": "https://bestcookieco.com"},
  company={
    "address": {
      "city": "Schenectady",
      "line1": "123 State St",
      "postal_code": "12345",
      "state": "NY",
    },
    "tax_id": "000000000",
    "name": "The Best Cookie Co",
    "phone": "8888675309",
  },
  individual={"first_name": "Jenny", "last_name": "Rosen"},
)
```
Code snippet calling post /v1/accounts/{cid} in python (service-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.accounts.update(
  "{{CONNECTED_ACCOUNT_ID}}",
  {
    "tos_acceptance": {"date": 1547923073, "ip": "172.18.80.19"},
    "settings": {
      "treasury": {"tos_acceptance": {"date": 1547923073, "ip": "172.18.80.19"}},
    },
    "business_profile": {"mcc": "5045", "url": "https://bestcookieco.com"},
    "company": {
      "address": {
        "city": "Schenectady",
        "line1": "123 State St",
        "postal_code": "12345",
        "state": "NY",
      },
      "tax_id": "000000000",
      "name": "The Best Cookie Co",
      "phone": "8888675309",
    },
    "individual": {"first_name": "Jenny", "last_name": "Rosen"},
  },
)
```
Code snippet calling post /v1/accounts/{cid} in php (resource-based pattern).
```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

$account = $stripe->accounts->update(
  '{{CONNECTED_ACCOUNT_ID}}',
  [
    'tos_acceptance' => [
      'date' => 1547923073,
      'ip' => '172.18.80.19',
    ],
    'settings' => [
      'treasury' => [
        'tos_acceptance' => [
          'date' => 1547923073,
          'ip' => '172.18.80.19',
        ],
      ],
    ],
    'business_profile' => [
      'mcc' => '5045',
      'url' => 'https://bestcookieco.com',
    ],
    'company' => [
      'address' => [
        'city' => 'Schenectady',
        'line1' => '123 State St',
        'postal_code' => '12345',
        'state' => 'NY',
      ],
      'tax_id' => '000000000',
      'name' => 'The Best Cookie Co',
      'phone' => '8888675309',
    ],
    'individual' => [
      'first_name' => 'Jenny',
      'last_name' => 'Rosen',
    ],
  ]
);
```
Code snippet calling post /v1/accounts/{cid} in java (resource-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

Account resource = Account.retrieve("{{CONNECTED_ACCOUNT_ID}}");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setTosAcceptance(
      AccountUpdateParams.TosAcceptance.builder()
        .setDate(1547923073L)
        .setIp("172.18.80.19")
        .build()
    )
    .setSettings(
      AccountUpdateParams.Settings.builder()
        .setTreasury(
          AccountUpdateParams.Settings.Treasury.builder()
            .setTosAcceptance(
              AccountUpdateParams.Settings.Treasury.TosAcceptance.builder()
                .setDate(1547923073L)
                .setIp("172.18.80.19")
                .build()
            )
            .build()
        )
        .build()
    )
    .setBusinessProfile(
      AccountUpdateParams.BusinessProfile.builder()
        .setMcc("5045")
        .setUrl("https://bestcookieco.com")
        .build()
    )
    .setCompany(
      AccountUpdateParams.Company.builder()
        .setAddress(
          AccountUpdateParams.Company.Address.builder()
            .setCity("Schenectady")
            .setLine1("123 State St")
            .setPostalCode("12345")
            .setState("NY")
            .build()
        )
        .setTaxId("000000000")
        .setName("The Best Cookie Co")
        .setPhone("8888675309")
        .build()
    )
    .setIndividual(
      AccountUpdateParams.Individual.builder()
        .setFirstName("Jenny")
        .setLastName("Rosen")
        .build()
    )
    .build();

Account account = resource.update(params);
```
Code snippet calling post /v1/accounts/{cid} in java (service-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setTosAcceptance(
      AccountUpdateParams.TosAcceptance.builder()
        .setDate(1547923073L)
        .setIp("172.18.80.19")
        .build()
    )
    .setSettings(
      AccountUpdateParams.Settings.builder()
        .setTreasury(
          AccountUpdateParams.Settings.Treasury.builder()
            .setTosAcceptance(
              AccountUpdateParams.Settings.Treasury.TosAcceptance.builder()
                .setDate(1547923073L)
                .setIp("172.18.80.19")
                .build()
            )
            .build()
        )
        .build()
    )
    .setBusinessProfile(
      AccountUpdateParams.BusinessProfile.builder()
        .setMcc("5045")
        .setUrl("https://bestcookieco.com")
        .build()
    )
    .setCompany(
      AccountUpdateParams.Company.builder()
        .setAddress(
          AccountUpdateParams.Company.Address.builder()
            .setCity("Schenectady")
            .setLine1("123 State St")
            .setPostalCode("12345")
            .setState("NY")
            .build()
        )
        .setTaxId("000000000")
        .setName("The Best Cookie Co")
        .setPhone("8888675309")
        .build()
    )
    .setIndividual(
      AccountUpdateParams.Individual.builder()
        .setFirstName("Jenny")
        .setLastName("Rosen")
        .build()
    )
    .build();

Account account = client.accounts().update("{{CONNECTED_ACCOUNT_ID}}", params);
```
Code snippet calling post /v1/accounts/{cid} in node (resource-based pattern).
```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

const account = await stripe.accounts.update(
  '{{CONNECTED_ACCOUNT_ID}}',
  {
    tos_acceptance: {
      date: 1547923073,
      ip: '172.18.80.19',
    },
    settings: {
      treasury: {
        tos_acceptance: {
          date: 1547923073,
          ip: '172.18.80.19',
        },
      },
    },
    business_profile: {
      mcc: '5045',
      url: 'https://bestcookieco.com',
    },
    company: {
      address: {
        city: 'Schenectady',
        line1: '123 State St',
        postal_code: '12345',
        state: 'NY',
      },
      tax_id: '000000000',
      name: 'The Best Cookie Co',
      phone: '8888675309',
    },
    individual: {
      first_name: 'Jenny',
      last_name: 'Rosen',
    },
  }
);
```
Code snippet calling post /v1/accounts/{cid} in dotnet (resource-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeConfiguration.ApiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

var options = new AccountUpdateOptions
{
    TosAcceptance = new AccountTosAcceptanceOptions
    {
        Date = DateTimeOffset.FromUnixTimeSeconds(1547923073).UtcDateTime,
        Ip = "172.18.80.19",
    },
    Settings = new AccountSettingsOptions
    {
        Treasury = new AccountSettingsTreasuryOptions
        {
            TosAcceptance = new AccountSettingsTreasuryTosAcceptanceOptions
            {
                Date = DateTimeOffset.FromUnixTimeSeconds(1547923073).UtcDateTime,
                Ip = "172.18.80.19",
            },
        },
    },
    BusinessProfile = new AccountBusinessProfileOptions
    {
        Mcc = "5045",
        Url = "https://bestcookieco.com",
    },
    Company = new AccountCompanyOptions
    {
        Address = new AddressOptions
        {
            City = "Schenectady",
            Line1 = "123 State St",
            PostalCode = "12345",
            State = "NY",
        },
        TaxId = "000000000",
        Name = "The Best Cookie Co",
        Phone = "8888675309",
    },
    Individual = new AccountIndividualOptions { FirstName = "Jenny", LastName = "Rosen" },
};
var service = new AccountService();
Account account = service.Update("{{CONNECTED_ACCOUNT_ID}}", options);
```
Code snippet calling post /v1/accounts/{cid} in dotnet (service-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new AccountUpdateOptions
{
    TosAcceptance = new AccountTosAcceptanceOptions
    {
        Date = DateTimeOffset.FromUnixTimeSeconds(1547923073).UtcDateTime,
        Ip = "172.18.80.19",
    },
    Settings = new AccountSettingsOptions
    {
        Treasury = new AccountSettingsTreasuryOptions
        {
            TosAcceptance = new AccountSettingsTreasuryTosAcceptanceOptions
            {
                Date = DateTimeOffset.FromUnixTimeSeconds(1547923073).UtcDateTime,
                Ip = "172.18.80.19",
            },
        },
    },
    BusinessProfile = new AccountBusinessProfileOptions
    {
        Mcc = "5045",
        Url = "https://bestcookieco.com",
    },
    Company = new AccountCompanyOptions
    {
        Address = new AddressOptions
        {
            City = "Schenectady",
            Line1 = "123 State St",
            PostalCode = "12345",
            State = "NY",
        },
        TaxId = "000000000",
        Name = "The Best Cookie Co",
        Phone = "8888675309",
    },
    Individual = new AccountIndividualOptions { FirstName = "Jenny", LastName = "Rosen" },
};
var client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
var service = client.V1.Accounts;
Account account = service.Update("{{CONNECTED_ACCOUNT_ID}}", options);
```
Code snippet calling post /v1/accounts/{cid} in go (resource-based pattern).
```go

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
stripe.Key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

params := &stripe.AccountParams{
  TOSAcceptance: &stripe.AccountTOSAcceptanceParams{
    Date: stripe.Int64(1547923073),
    IP: stripe.String("172.18.80.19"),
  },
  Settings: &stripe.Settings{
    Treasury: &stripe.Settings.Treasury{
      TOSAcceptance: &stripe.Settings.Treasury.TOSAcceptance{
        Date: stripe.Int64(1547923073),
        IP: stripe.String("172.18.80.19"),
      }
    }
  },
  BusinessProfile: &stripe.AccountBusinessProfileParams{
    MCC: stripe.String("5045"),
    URL: stripe.String("https://bestcookieco.com"),
  },
  Company: &stripe.AccountCompanyParams{
    Address: &stripe.AccountCompanyAddressParams{
      City: stripe.String("Schenectady"),
      Line1: stripe.String("123 State St"),
      PostalCode: stripe.String("12345"),
      State: stripe.String("NY"),
    },
    TaxID: stripe.String("000000000"),
    Name: stripe.String("The Best Cookie Co"),
    Phone: stripe.String("8888675309"),
  },
  Individual: &stripe.AccountIndividualParams{
    FirstName: stripe.String("Jenny"),
    LastName: stripe.String("Rosen"),
  },
};
result, _ := account.Update("{{CONNECTED_ACCOUNT_ID}}", params);
```

### Using hosted onboarding

Use Connect Onboarding to efficiently collect required information. That offloads the verification complexity from your platform to Stripe and collects the terms of the service agreement. Alternatively, you can write your own API requests for initial integration, but must monitor for changes to compliance requirements to keep your onboarding workflow current. Learn how to [create connected accounts](https://stripe.com/connect/design-an-integration?connect-onboarding-surface=api&connect-dashboard-type=none&connect-economic-model=buy-rate&connect-loss-liability-owner=platform&connect-charge-type=direct) that work with Treasury.

Before you can use Connect Onboarding, you must provide the name, color, and icon of your brand in the **Branding** section of your [Connect settings page](https://dashboard.stripe.com/test/settings/connect). Doing so customizes the visual appearance of the form that sellers and service providers interact with when onboarding to your platform.

To take advantage of Connect Onboarding, use `POST /v1/account_links` to create an `AccountLink` to provide to the seller or service provider who’s going to take ownership of the connected account:

For security, don’t email, text, or otherwise send account link URLs directly to your user. Instead, redirect the authenticated user to the account link URL from within your platform’s application.
Code snippet calling post /v1/account_links in curl (resource-based pattern).
```curl
curl https://api.stripe.com/v1/account_links \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d account="{{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode refresh_url="https://example.com/reauth" \
  --data-urlencode return_url="https://example.com/return" \
  -d type=account_onboarding
```
Code snippet calling post /v1/account_links in cli (resource-based pattern).
```cli
stripe account_links create  \
  --account="{{CONNECTEDACCOUNT_ID}}" \
  --refresh-url="https://example.com/reauth" \
  --return-url="https://example.com/return" \
  --type=account_onboarding
```
Code snippet calling post /v1/account_links in ruby (resource-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

account_link = Stripe::AccountLink.create({
  account: '{{CONNECTEDACCOUNT_ID}}',
  refresh_url: 'https://example.com/reauth',
  return_url: 'https://example.com/return',
  type: 'account_onboarding',
})
```
Code snippet calling post /v1/account_links in ruby (service-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account_link = client.v1.account_links.create({
  account: '{{CONNECTEDACCOUNT_ID}}',
  refresh_url: 'https://example.com/reauth',
  return_url: 'https://example.com/return',
  type: 'account_onboarding',
})
```
Code snippet calling post /v1/account_links in python (resource-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
import stripe
stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

account_link = stripe.AccountLink.create(
  account="{{CONNECTEDACCOUNT_ID}}",
  refresh_url="https://example.com/reauth",
  return_url="https://example.com/return",
  type="account_onboarding",
)
```
Code snippet calling post /v1/account_links in python (service-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account_link = client.account_links.create({
  "account": "{{CONNECTEDACCOUNT_ID}}",
  "refresh_url": "https://example.com/reauth",
  "return_url": "https://example.com/return",
  "type": "account_onboarding",
})
```
Code snippet calling post /v1/account_links in php (resource-based pattern).
```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

$accountLink = $stripe->accountLinks->create([
  'account' => '{{CONNECTEDACCOUNT_ID}}',
  'refresh_url' => 'https://example.com/reauth',
  'return_url' => 'https://example.com/return',
  'type' => 'account_onboarding',
]);
```
Code snippet calling post /v1/account_links in java (resource-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

AccountLinkCreateParams params =
  AccountLinkCreateParams.builder()
    .setAccount("{{CONNECTEDACCOUNT_ID}}")
    .setRefreshUrl("https://example.com/reauth")
    .setReturnUrl("https://example.com/return")
    .setType(AccountLinkCreateParams.Type.ACCOUNT_ONBOARDING)
    .build();

AccountLink accountLink = AccountLink.create(params);
```
Code snippet calling post /v1/account_links in java (service-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");

AccountLinkCreateParams params =
  AccountLinkCreateParams.builder()
    .setAccount("{{CONNECTEDACCOUNT_ID}}")
    .setRefreshUrl("https://example.com/reauth")
    .setReturnUrl("https://example.com/return")
    .setType(AccountLinkCreateParams.Type.ACCOUNT_ONBOARDING)
    .build();

AccountLink accountLink = client.accountLinks().create(params);
```
Code snippet calling post /v1/account_links in node (resource-based pattern).
```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

const accountLink = await stripe.accountLinks.create({
  account: '{{CONNECTEDACCOUNT_ID}}',
  refresh_url: 'https://example.com/reauth',
  return_url: 'https://example.com/return',
  type: 'account_onboarding',
});
```
Code snippet calling post /v1/account_links in go (resource-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
stripe.Key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

params := &stripe.AccountLinkParams{
  Account: stripe.String("{{CONNECTEDACCOUNT_ID}}"),
  RefreshURL: stripe.String("https://example.com/reauth"),
  ReturnURL: stripe.String("https://example.com/return"),
  Type: stripe.String("account_onboarding"),
};
result, err := accountlink.New(params);
```
Code snippet calling post /v1/account_links in go (service-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys

sc := stripe.NewClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
params := &stripe.AccountLinkCreateParams{
  Account: stripe.String("{{CONNECTEDACCOUNT_ID}}"),
  RefreshURL: stripe.String("https://example.com/reauth"),
  ReturnURL: stripe.String("https://example.com/return"),
  Type: stripe.String("account_onboarding"),
};
result, err := sc.V1AccountLinks.Create(context.TODO(), params);
```
Code snippet calling post /v1/account_links in dotnet (resource-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeConfiguration.ApiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

var options = new AccountLinkCreateOptions
{
    Account = "{{CONNECTEDACCOUNT_ID}}",
    RefreshUrl = "https://example.com/reauth",
    ReturnUrl = "https://example.com/return",
    Type = "account_onboarding",
};
var service = new AccountLinkService();
AccountLink accountLink = service.Create(options);
```
Code snippet calling post /v1/account_links in dotnet (service-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new AccountLinkCreateOptions
{
    Account = "{{CONNECTEDACCOUNT_ID}}",
    RefreshUrl = "https://example.com/reauth",
    ReturnUrl = "https://example.com/return",
    Type = "account_onboarding",
};
var client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
var service = client.V1.AccountLinks;
AccountLink accountLink = service.Create(options);
```

The response you receive includes the URL to provide to your user.

```json
{
  "object": "account_link",
  "created": 1612927106,
  "expires_at": 1612927406,
  "url": "https://connect.stripe.com/setup/s/iCtLfmYb2tEU"
}
```

### Using embedded onboarding

Embedded onboarding is a themeable onboarding UI with limited Stripe branding. It gives you more UX control than Stripe’s hosted onboarding solution. With embedded onboarding, you get a customized onboarding flow without the complexity and maintenance associated with updating your onboarding integration as compliance requirements change.

Your platform embeds the [Account onboarding component](https://stripe.com/connect/supported-embedded-components/account-onboarding) in your application, and your connected accounts interact with the embedded component without leaving your application. Embedded onboarding uses the [Accounts API](https://stripe.com/api/accounts) to read the requirements and generate an onboarding form with robust data validation that’s localized for all Stripe-supported countries.

### Using custom onboarding

If you prefer to build custom onboarding for your users, use `POST /v1/accounts/{{CONNECTED_ACCOUNT_ID}}` and `POST /v1/accounts/{{CONNECTED_ACCOUNT_ID}}/persons/{{PERSON_ID}}` to update the relevant `Account` and `Person` objects with the required information.

You must also confirm that the connected account owner has read and agreed to the [Stripe Treasury Agreement](https://stripe.com/treasury-connect-account/legal). See [Handling verification with the API](https://stripe.com/connect/handling-api-verification) for additional details on fulfilling onboarding requirements.
Code snippet calling post /v1/accounts/{account} in curl (resource-based pattern).
```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTEDACCOUNT_ID}} \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d "company[name]"=Homebox \
  -d "company[address][line1]"="123 Market St." \
  -d "company[address][city]"="San Francisco" \
  -d "company[address][state]"=CA \
  -d "company[address][postal_code]"=94107 \
  -d "company[address][country]"=US
```
Code snippet calling post /v1/accounts/{account} in cli (resource-based pattern).
```cli
stripe accounts update {{CONNECTEDACCOUNT_ID}} \
  -d "company[name]"=Homebox \
  -d "company[address][line1]"="123 Market St." \
  -d "company[address][city]"="San Francisco" \
  -d "company[address][state]"=CA \
  -d "company[address][postal_code]"=94107 \
  -d "company[address][country]"=US
```
Code snippet calling post /v1/accounts/{account} in ruby (resource-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

account = Stripe::Account.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    company: {
      name: 'Homebox',
      address: {
        line1: '123 Market St.',
        city: 'San Francisco',
        state: 'CA',
        postal_code: '94107',
        country: 'US',
      },
    },
  },
)
```
Code snippet calling post /v1/accounts/{account} in ruby (service-based pattern).
```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.v1.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    company: {
      name: 'Homebox',
      address: {
        line1: '123 Market St.',
        city: 'San Francisco',
        state: 'CA',
        postal_code: '94107',
        country: 'US',
      },
    },
  },
)
```
Code snippet calling post /v1/accounts/{account} in python (resource-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
import stripe
stripe.api_key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

account = stripe.Account.modify(
  "{{CONNECTEDACCOUNT_ID}}",
  company={
    "name": "Homebox",
    "address": {
      "line1": "123 Market St.",
      "city": "San Francisco",
      "state": "CA",
      "postal_code": "94107",
      "country": "US",
    },
  },
)
```
Code snippet calling post /v1/accounts/{account} in python (service-based pattern).
```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2")

account = client.accounts.update(
  "{{CONNECTEDACCOUNT_ID}}",
  {
    "company": {
      "name": "Homebox",
      "address": {
        "line1": "123 Market St.",
        "city": "San Francisco",
        "state": "CA",
        "postal_code": "94107",
        "country": "US",
      },
    },
  },
)
```
Code snippet calling post /v1/accounts/{account} in php (resource-based pattern).
```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

$account = $stripe->accounts->update(
  '{{CONNECTEDACCOUNT_ID}}',
  [
    'company' => [
      'name' => 'Homebox',
      'address' => [
        'line1' => '123 Market St.',
        'city' => 'San Francisco',
        'state' => 'CA',
        'postal_code' => '94107',
        'country' => 'US',
      ],
    ],
  ]
);
```
Code snippet calling post /v1/accounts/{account} in java (resource-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
Stripe.apiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

Account resource = Account.retrieve("{{CONNECTEDACCOUNT_ID}}");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setCompany(
      AccountUpdateParams.Company.builder()
        .setName("Homebox")
        .setAddress(
          AccountUpdateParams.Company.Address.builder()
            .setLine1("123 Market St.")
            .setCity("San Francisco")
            .setState("CA")
            .setPostalCode("94107")
            .setCountry("US")
            .build()
        )
        .build()
    )
    .build();

Account account = resource.update(params);
```
Code snippet calling post /v1/accounts/{account} in java (service-based pattern).
```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setCompany(
      AccountUpdateParams.Company.builder()
        .setName("Homebox")
        .setAddress(
          AccountUpdateParams.Company.Address.builder()
            .setLine1("123 Market St.")
            .setCity("San Francisco")
            .setState("CA")
            .setPostalCode("94107")
            .setCountry("US")
            .build()
        )
        .build()
    )
    .build();

Account account = client.accounts().update("{{CONNECTEDACCOUNT_ID}}", params);
```
Code snippet calling post /v1/accounts/{account} in node (resource-based pattern).
```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('sk_test_BQokikJOvBiI2HlWgH4olfQ2');

const account = await stripe.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    company: {
      name: 'Homebox',
      address: {
        line1: '123 Market St.',
        city: 'San Francisco',
        state: 'CA',
        postal_code: '94107',
        country: 'US',
      },
    },
  }
);
```
Code snippet calling post /v1/accounts/{account} in go (resource-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
stripe.Key = "sk_test_BQokikJOvBiI2HlWgH4olfQ2"

params := &stripe.AccountParams{
  Company: &stripe.AccountCompanyParams{
    Name: stripe.String("Homebox"),
    Address: &stripe.AccountCompanyAddressParams{
      Line1: stripe.String("123 Market St."),
      City: stripe.String("San Francisco"),
      State: stripe.String("CA"),
      PostalCode: stripe.String("94107"),
      Country: stripe.String("US"),
    },
  },
};
result, err := account.Update("{{CONNECTEDACCOUNT_ID}}", params);
```
Code snippet calling post /v1/accounts/{account} in go (service-based pattern).
```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys

sc := stripe.NewClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
params := &stripe.AccountUpdateParams{
  Company: &stripe.AccountUpdateCompanyParams{
    Name: stripe.String("Homebox"),
    Address: &stripe.AccountUpdateCompanyAddressParams{
      Line1: stripe.String("123 Market St."),
      City: stripe.String("San Francisco"),
      State: stripe.String("CA"),
      PostalCode: stripe.String("94107"),
      Country: stripe.String("US"),
    },
  },
  Account: stripe.String("{{CONNECTEDACCOUNT_ID}}"),
};
result, err := sc.V1Accounts.Update(context.TODO(), params);
```
Code snippet calling post /v1/accounts/{account} in dotnet (resource-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeConfiguration.ApiKey = "sk_test_BQokikJOvBiI2HlWgH4olfQ2";

var options = new AccountUpdateOptions
{
    Company = new AccountCompanyOptions
    {
        Name = "Homebox",
        Address = new AddressOptions
        {
            Line1 = "123 Market St.",
            City = "San Francisco",
            State = "CA",
            PostalCode = "94107",
            Country = "US",
        },
    },
};
var service = new AccountService();
Account account = service.Update("{{CONNECTEDACCOUNT_ID}}", options);
```
Code snippet calling post /v1/accounts/{account} in dotnet (service-based pattern).
```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new AccountUpdateOptions
{
    Company = new AccountCompanyOptions
    {
        Name = "Homebox",
        Address = new AddressOptions
        {
            Line1 = "123 Market St.",
            City = "San Francisco",
            State = "CA",
            PostalCode = "94107",
            Country = "US",
        },
    },
};
var client = new StripeClient("sk_test_BQokikJOvBiI2HlWgH4olfQ2");
var service = client.V1.Accounts;
Account account = service.Update("{{CONNECTEDACCOUNT_ID}}", options);
```

### Requirements

The fields in the following table are required for Treasury users.

| Entity type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | At onboarding                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Individual, Sole proprietorship                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Entity details:
  - Business names (customer facing and legal)
  - Legal entity type
  - Business address
  - Business phone number
  - Product or service description
  - Industry or Merchant category code
  - Tax ID Number (SSN, ITIN, or EIN)
  - Treasury TOS acceptance
  - Stripe TOS acceptance
Owner details:
  - Legal name
  - Date of birth
  - Email address
  - Residential address
  - Full SSN, or ID document scan for non-US persons or if SSN can’t be verified
  - Title
  - Phone number                                   |
| Companies (LLCs, corporations, non-profits, partnerships, and so on)                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Entity details:
  - Business names (customer facing and legal)
  - Legal entity type
  - Business address
  - Business phone number
  - Product or service description
  - Industry or Merchant category code
  - Tax ID Number (EIN)
  - Treasury TOS acceptance
  - Stripe TOS acceptance
Owner/representative details:
  - Legal name
  - Date of birth
  - Email address
  - Residential address
  - Phone number
  - Title
  - Percent ownership of company
  - Full SSN, or ID document scan for non-US persons or if SSN can’t be verified |

### Completion

The connected account onboarding process is complete when you receive an `account.updated` [webhook](https://stripe.com/webhooks) confirming the following fields on your connected account:

```
{
  "object": {
    "object": "account",
    "id": "acct_1234",
    "capabilities": {
      "treasury": "active",
      "card_issuing": "active", // Only appears if requesting the `card_issuing` capability.
      "us_bank_account_ach_payments": "active", // Only appears if requesting the `us_bank_account_ach_payments` capability.
    },
    ...
  }
}
```

Account onboarding latency when your platform’s bank partner is Evolve Bank & Trust is less than 5 minutes.

### Updates to requirements

To adapt to changes in financial regulations, Stripe must occasionally update information collection requirements for Treasury. The `requirements.eventually_due` array on the `Account` object captures the updated information required by these regulation changes. Learn more about the [requirements](https://stripe.com/api/accounts/object#account_object-requirements) hash.