# Service agreement types

Learn how a service agreement establishes the relationship between Stripe and a platform's users.

The connected account’s service agreement type determines what [capabilities](https://docs.stripe.com/connect/account-capabilities.md) the account has access to, and which service agreement applies to the platform’s users.

This content is only applicable if your platform is liable for negative balances and your connected accounts don’t have access to the full Stripe Dashboard, which includes Express and Custom accounts.

## Supported agreement types 

Connected accounts can be under one of the following service agreement types: `full` or `recipient`. After a connected account accepts it, you can’t modify the type of service agreement.

### Full service agreement 

A `full` service agreement creates a service relationship between Stripe and the connected account holder. Connected accounts under the `full` service agreement can process card payments and request the [card_payments](https://docs.stripe.com/connect/account-capabilities.md#card-payments) capability.

For the legal language, see the [Stripe Connected Account Agreement](https://stripe.com/connect-account/legal/full).

### Recipient service agreement 

A [recipient service agreement](https://stripe.com/connect-account/legal/recipient) acknowledges that Stripe has no direct service relationship with the recipient. Instead, the recipient has a relationship only with the platform. Accounts under this agreement can’t process payments or request the `card_payments` capability. Transfers to `recipient` accounts take an additional 24 hours to become available in the [connected account’s balance](https://docs.stripe.com/connect/account-balances.md).

The recipient service agreement is available in select countries. Refer to the [required verification information](https://docs.stripe.com/connect/required-verification-information.md) to verify the supported countries.

Stripe supports cross-border payouts for platforms using a `recipient` service agreement through [Global payouts](https://docs.stripe.com/global-payouts.md). Stripe doesn’t provide direct support to accounts on the `recipient` service agreement, but you (the platform) can contact Stripe for support on behalf of those accounts.

## Choosing the agreement type 

You can specify the agreement type through the [Accounts](https://docs.stripe.com/api/accounts.md) API.

### Accounts API 

To choose a `recipient` service agreement when [creating an account](https://docs.stripe.com/api.md#create_account), specify the agreement type with [tos_acceptance[service_agreement]](https://docs.stripe.com/api/accounts/object.md#account_object-tos_acceptance):

#### With controller properties

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d country=US \
  -d "controller[stripe_dashboard][type]"=none \
  -d "controller[fees][payer]"=application \
  -d "controller[losses][payments]"=application \
  -d "controller[requirement_collection]"=application \
  -d "capabilities[transfers][requested]"=true \
  -d "tos_acceptance[service_agreement]"=recipient
```

```cli
stripe accounts create  \
  --country=US \
  -d "controller[stripe_dashboard][type]"=none \
  -d "controller[fees][payer]"=application \
  -d "controller[losses][payments]"=application \
  -d "controller[requirement_collection]"=application \
  -d "capabilities[transfers][requested]"=true \
  -d "tos_acceptance[service_agreement]"=recipient
```

```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("<<YOUR_SECRET_KEY>>")

account = client.v1.accounts.create({
  country: 'US',
  controller: {
    stripe_dashboard: {type: 'none'},
    fees: {payer: 'application'},
    losses: {payments: 'application'},
    requirement_collection: 'application',
  },
  capabilities: {transfers: {requested: true}},
  tos_acceptance: {service_agreement: 'recipient'},
})
```

```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("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
account = client.v1.accounts.create({
  "country": "US",
  "controller": {
    "stripe_dashboard": {"type": "none"},
    "fees": {"payer": "application"},
    "losses": {"payments": "application"},
    "requirement_collection": "application",
  },
  "capabilities": {"transfers": {"requested": True}},
  "tos_acceptance": {"service_agreement": "recipient"},
})
```

```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('<<YOUR_SECRET_KEY>>');

$account = $stripe->accounts->create([
  'country' => 'US',
  'controller' => [
    'stripe_dashboard' => ['type' => 'none'],
    'fees' => ['payer' => 'application'],
    'losses' => ['payments' => 'application'],
    'requirement_collection' => 'application',
  ],
  'capabilities' => ['transfers' => ['requested' => true]],
  'tos_acceptance' => ['service_agreement' => 'recipient'],
]);
```

```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("<<YOUR_SECRET_KEY>>");

AccountCreateParams params =
  AccountCreateParams.builder()
    .setCountry("US")
    .setController(
      AccountCreateParams.Controller.builder()
        .setStripeDashboard(
          AccountCreateParams.Controller.StripeDashboard.builder()
            .setType(AccountCreateParams.Controller.StripeDashboard.Type.NONE)
            .build()
        )
        .setFees(
          AccountCreateParams.Controller.Fees.builder()
            .setPayer(AccountCreateParams.Controller.Fees.Payer.APPLICATION)
            .build()
        )
        .setLosses(
          AccountCreateParams.Controller.Losses.builder()
            .setPayments(AccountCreateParams.Controller.Losses.Payments.APPLICATION)
            .build()
        )
        .setRequirementCollection(
          AccountCreateParams.Controller.RequirementCollection.APPLICATION
        )
        .build()
    )
    .setCapabilities(
      AccountCreateParams.Capabilities.builder()
        .setTransfers(
          AccountCreateParams.Capabilities.Transfers.builder().setRequested(true).build()
        )
        .build()
    )
    .setTosAcceptance(
      AccountCreateParams.TosAcceptance.builder().setServiceAgreement("recipient").build()
    )
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Account account = client.v1().accounts().create(params);
```

```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')('<<YOUR_SECRET_KEY>>');

const account = await stripe.accounts.create({
  country: 'US',
  controller: {
    stripe_dashboard: {
      type: 'none',
    },
    fees: {
      payer: 'application',
    },
    losses: {
      payments: 'application',
    },
    requirement_collection: 'application',
  },
  capabilities: {
    transfers: {
      requested: true,
    },
  },
  tos_acceptance: {
    service_agreement: 'recipient',
  },
});
```

```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("<<YOUR_SECRET_KEY>>")
params := &stripe.AccountCreateParams{
  Country: stripe.String("US"),
  Controller: &stripe.AccountCreateControllerParams{
    StripeDashboard: &stripe.AccountCreateControllerStripeDashboardParams{
      Type: stripe.String(stripe.AccountControllerStripeDashboardTypeNone),
    },
    Fees: &stripe.AccountCreateControllerFeesParams{
      Payer: stripe.String(stripe.AccountControllerFeesPayerApplication),
    },
    Losses: &stripe.AccountCreateControllerLossesParams{
      Payments: stripe.String(stripe.AccountControllerLossesPaymentsApplication),
    },
    RequirementCollection: stripe.String(stripe.AccountControllerRequirementCollectionApplication),
  },
  Capabilities: &stripe.AccountCreateCapabilitiesParams{
    Transfers: &stripe.AccountCreateCapabilitiesTransfersParams{
      Requested: stripe.Bool(true),
    },
  },
  TOSAcceptance: &stripe.AccountCreateTOSAcceptanceParams{
    ServiceAgreement: stripe.String("recipient"),
  },
}
result, err := sc.V1Accounts.Create(context.TODO(), params)
```

```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 AccountCreateOptions
{
    Country = "US",
    Controller = new AccountControllerOptions
    {
        StripeDashboard = new AccountControllerStripeDashboardOptions { Type = "none" },
        Fees = new AccountControllerFeesOptions { Payer = "application" },
        Losses = new AccountControllerLossesOptions { Payments = "application" },
        RequirementCollection = "application",
    },
    Capabilities = new AccountCapabilitiesOptions
    {
        Transfers = new AccountCapabilitiesTransfersOptions { Requested = true },
    },
    TosAcceptance = new AccountTosAcceptanceOptions { ServiceAgreement = "recipient" },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Accounts;
Account account = service.Create(options);
```

#### With account type

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d country=US \
  -d type=custom \
  -d "capabilities[transfers][requested]"=true \
  -d "tos_acceptance[service_agreement]"=recipient
```

```cli
stripe accounts create  \
  --country=US \
  --type=custom \
  -d "capabilities[transfers][requested]"=true \
  -d "tos_acceptance[service_agreement]"=recipient
```

```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("<<YOUR_SECRET_KEY>>")

account = client.v1.accounts.create({
  country: 'US',
  type: 'custom',
  capabilities: {transfers: {requested: true}},
  tos_acceptance: {service_agreement: 'recipient'},
})
```

```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("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
account = client.v1.accounts.create({
  "country": "US",
  "type": "custom",
  "capabilities": {"transfers": {"requested": True}},
  "tos_acceptance": {"service_agreement": "recipient"},
})
```

```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('<<YOUR_SECRET_KEY>>');

$account = $stripe->accounts->create([
  'country' => 'US',
  'type' => 'custom',
  'capabilities' => ['transfers' => ['requested' => true]],
  'tos_acceptance' => ['service_agreement' => 'recipient'],
]);
```

```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("<<YOUR_SECRET_KEY>>");

AccountCreateParams params =
  AccountCreateParams.builder()
    .setCountry("US")
    .setType(AccountCreateParams.Type.CUSTOM)
    .setCapabilities(
      AccountCreateParams.Capabilities.builder()
        .setTransfers(
          AccountCreateParams.Capabilities.Transfers.builder().setRequested(true).build()
        )
        .build()
    )
    .setTosAcceptance(
      AccountCreateParams.TosAcceptance.builder().setServiceAgreement("recipient").build()
    )
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Account account = client.v1().accounts().create(params);
```

```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')('<<YOUR_SECRET_KEY>>');

const account = await stripe.accounts.create({
  country: 'US',
  type: 'custom',
  capabilities: {
    transfers: {
      requested: true,
    },
  },
  tos_acceptance: {
    service_agreement: 'recipient',
  },
});
```

```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("<<YOUR_SECRET_KEY>>")
params := &stripe.AccountCreateParams{
  Country: stripe.String("US"),
  Type: stripe.String(stripe.AccountTypeCustom),
  Capabilities: &stripe.AccountCreateCapabilitiesParams{
    Transfers: &stripe.AccountCreateCapabilitiesTransfersParams{
      Requested: stripe.Bool(true),
    },
  },
  TOSAcceptance: &stripe.AccountCreateTOSAcceptanceParams{
    ServiceAgreement: stripe.String("recipient"),
  },
}
result, err := sc.V1Accounts.Create(context.TODO(), params)
```

```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 AccountCreateOptions
{
    Country = "US",
    Type = "custom",
    Capabilities = new AccountCapabilitiesOptions
    {
        Transfers = new AccountCapabilitiesTransfersOptions { Requested = true },
    },
    TosAcceptance = new AccountTosAcceptanceOptions { ServiceAgreement = "recipient" },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Accounts;
Account account = service.Create(options);
```

The same principle applies when [updating an account](https://docs.stripe.com/api.md#update_account):

```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTEDACCOUNT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "tos_acceptance[service_agreement]"=recipient
```

```cli
stripe accounts update {{CONNECTEDACCOUNT_ID}} \
  -d "tos_acceptance[service_agreement]"=recipient
```

```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("<<YOUR_SECRET_KEY>>")

account = client.v1.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {tos_acceptance: {service_agreement: 'recipient'}},
)
```

```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("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
account = client.v1.accounts.update(
  "{{CONNECTEDACCOUNT_ID}}",
  {"tos_acceptance": {"service_agreement": "recipient"}},
)
```

```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('<<YOUR_SECRET_KEY>>');

$account = $stripe->accounts->update(
  '{{CONNECTEDACCOUNT_ID}}',
  ['tos_acceptance' => ['service_agreement' => 'recipient']]
);
```

```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("<<YOUR_SECRET_KEY>>");

AccountUpdateParams params =
  AccountUpdateParams.builder()
    .setTosAcceptance(
      AccountUpdateParams.TosAcceptance.builder().setServiceAgreement("recipient").build()
    )
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Account account = client.v1().accounts().update("{{CONNECTEDACCOUNT_ID}}", params);
```

```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')('<<YOUR_SECRET_KEY>>');

const account = await stripe.accounts.update(
  '{{CONNECTEDACCOUNT_ID}}',
  {
    tos_acceptance: {
      service_agreement: 'recipient',
    },
  }
);
```

```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("<<YOUR_SECRET_KEY>>")
params := &stripe.AccountUpdateParams{
  TOSAcceptance: &stripe.AccountUpdateTOSAcceptanceParams{
    ServiceAgreement: stripe.String("recipient"),
  },
}
result, err := sc.V1Accounts.Update(
  context.TODO(), "{{CONNECTEDACCOUNT_ID}}", params)
```

```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 { ServiceAgreement = "recipient" },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Accounts;
Account account = service.Update("{{CONNECTEDACCOUNT_ID}}", options);
```

> Changing the service agreement type fails if the service agreement has already been accepted; in those cases, create a new account with the desired service agreement.

### Connect Configuration settings

To choose a `recipient` service agreement for connected accounts with access to the Express Dashboard, select the **Transfers** option with the **Restricted Capability Access** icon in the [Configuration settings](https://dashboard.stripe.com/account/applications/settings/express) section of the Stripe Dashboard.

You can override the Configuration settings for an individual account by specifying its capabilities and service agreement type with the Accounts API.

## Accepting the correct agreement

Stripe handles the service agreement acceptance if you use [Stripe-hosted onboarding](https://docs.stripe.com/connect/hosted-onboarding.md) or [Embedded onboarding](https://docs.stripe.com/connect/embedded-onboarding.md). For [API onboarding](https://docs.stripe.com/connect/api-onboarding.md), the platform must attest that their user has seen and accepted the service agreement. See [service agreement acceptance](https://docs.stripe.com/connect/updating-service-agreements.md#tos-acceptance) for more information.