# Making API calls for connected accounts

Learn how to add the right information to your API calls so you can make calls for your connected accounts.

You can make API calls for your connected accounts:

* Server-side with the [Stripe-Account header](#stripe-account-header) and the connected account ID, per request
* Client-side by passing the connected account ID as an argument to the client library

To help with performance and reliability, Stripe has established [rate limits and allocations](https://docs.stripe.com/rate-limits.md) for API endpoints.

## Adding the Stripe-Account header server-side 

To make server-side API calls for connected accounts, use the `Stripe-Account` header with the account identifier, which begins with the prefix `acct_`. Here are four examples using your platform’s [API secret key](https://docs.stripe.com/keys.md) and the connected account’s [Account](https://docs.stripe.com/api/accounts.md) identifier:

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

var options = new PaymentIntentCreateOptions { Amount = 1000, Currency = "usd" };
var service = new PaymentIntentService();
PaymentIntent paymentIntent = service.Create(options);
```

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

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1000),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
};
result, err := paymentintent.New(params);
```

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

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder().setAmount(1000L).setCurrency("usd").build();

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

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

const paymentIntent = await stripe.paymentIntents.create({
  amount: 1000,
  currency: 'usd',
});
```

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

payment_intent = stripe.PaymentIntent.create(
  amount=1000,
  currency="usd",
)
```

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

$paymentIntent = $stripe->paymentIntents->create([
  'amount' => 1000,
  'currency' => 'usd',
]);
```

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

payment_intent = Stripe::PaymentIntent.create({
  amount: 1000,
  currency: 'usd',
})
```

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

var options = new BalanceGetOptions();
var service = new BalanceService();
Balance balance = service.Get(options);
```

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

params := &stripe.BalanceParams{};
result, err := balance.Get(params);
```

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

Balance balance = Balance.retrieve();
```

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

const balance = await stripe.balance.retrieve();
```

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

balance = stripe.Balance.retrieve()
```

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

$balance = $stripe->balance->retrieve([]);
```

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

balance = Stripe::Balance.retrieve()
```

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

var options = new ProductListOptions { Limit = 5 };
var service = new ProductService();
StripeList<Product> products = service.List(options);
```

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

params := &stripe.ProductListParams{};
params.Limit = stripe.Int64(5)
result := product.List(params);
```

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

ProductListParams params = ProductListParams.builder().setLimit(5L).build();

ProductCollection products = Product.list(params);
```

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

const products = await stripe.products.list({
  limit: 5,
});
```

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

products = stripe.Product.list(limit=5)
```

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

$products = $stripe->products->all(['limit' => 5]);
```

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

products = Stripe::Product.list({limit: 5})
```

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

var service = new CustomerService();
Customer deleted = service.Delete("{{CUSTOMER_ID}}");
```

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

params := &stripe.CustomerParams{};
result, err := customer.Del("{{CUSTOMER_ID}}", params);
```

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

Customer resource = Customer.retrieve("{{CUSTOMER_ID}}");

Customer customer = resource.delete();
```

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

const deleted = await stripe.customers.del('{{CUSTOMER_ID}}');
```

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

deleted = stripe.Customer.delete("{{CUSTOMER_ID}}")
```

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

$deleted = $stripe->customers->delete('{{CUSTOMER_ID}}', []);
```

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

deleted = Stripe::Customer.delete('{{CUSTOMER_ID}}')
```

The `Stripe-Account` header approach is implied in any API request that includes the Stripe account ID in the URL. Here’s an example that shows how to [Retrieve an account](https://docs.stripe.com/api/accounts/retrieve.md) with your user’s [Account](https://docs.stripe.com/api/accounts.md) identifier in the URL.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

All of Stripe’s server-side libraries support this approach on a per-request basis:

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

var options = new CustomerCreateOptions { Email = "person@example.com" };
var service = new CustomerService();
Customer customer = service.Create(options);
```

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

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

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

CustomerCreateParams params = CustomerCreateParams.builder().setEmail("person@example.com").build();

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

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

const customer = await stripe.customers.create({
  email: 'person@example.com',
});
```

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

customer = stripe.Customer.create(email="person@example.com")
```

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

$customer = $stripe->customers->create(['email' => 'person@example.com']);
```

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

customer = Stripe::Customer.create({email: 'person@example.com'})
```

## Adding the connected account ID to a client-side application

Client-side libraries set the connected account ID as an argument to the client application:

The JavaScript code for passing the connected account ID client-side is the same for plain JS and for ESNext.

```javascript
var stripe = Stripe('<<publishable key>>', {
  stripeAccount: '<<connectedAccount>>',
});
```

```javascript
import {loadStripe} from '@stripe/stripe-js';

// Make sure to call `loadStripe` outside of a component's render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<publishable key>>', {
  stripeAccount: '<<connectedAccount>>',
});
```

```swift
import UIKit
import StripePayments

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        StripeAPI.defaultPublishableKey = "<<publishable key>>"
        STPAPIClient.shared.stripeAccount = "<<connectedAccount>>"
        return true
    }
}
```

```objc
\#import "AppDelegate.h"
@import StripeCore;
@import StripePayments;

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [StripeAPI setDefaultPublishableKey:@"<<publishable key>>"];
    [[STPAPIClient sharedClient] setStripeAccount:@"<<connectedAccount>>"];
    return YES;
}
@end
```

```kotlin
import com.stripe.android.PaymentConfiguration

class MyActivity: Activity() {
    private lateinit var stripe: Stripe

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        stripe = Stripe(
            this,
            PaymentConfiguration.getInstance(this).publishableKey,
            "<<connectedAccount>>"
        )
    }
}
```

```java
import com.stripe.android.PaymentConfiguration;

public class MyActivity extends Activity {
    private Stripe stripe;

    @Override
    public void onCreate(@Nullable Bundle savedInstancedState) {
        super.onCreate(savedInstancedState);
        stripe = new Stripe(
            this,
            PaymentConfiguration.getInstance(this).getPublishableKey(),
            "<<connectedAccount>>"
        );
    }
}
```

```javascript
import {StripeProvider} from '@stripe/stripe-react-native';

function App() {
  return (
    <StripeProvider
      publishableKey="<<publishable key>>"
      stripeAccountId="<<connectedAccount>>"
    >
      // Your app code here
    </StripeProvider>
  );
}
```

## See Also

* [Creating charges](https://docs.stripe.com/connect/charges.md)
* [Using subscriptions](https://docs.stripe.com/connect/subscriptions.md)