# B2B Payments integration guide

Build a B2B Payments integration with Issuing.

Check out our introductory guide to using [BaaS for SaaS Platforms](https://stripe.com/guides/introduction-to-banking-as-a-service).

Build a US B2B Payments integration by using Stripe [Issuing](https://docs.stripe.com/issuing/how-issuing-works.md) to create cards for your business, employees, or contractors to make purchases on your behalf.

By the end of this guide, you’ll know how to:

- Fund your Issuing Balance
- Create virtual cards for your own business
- Use these cards to spend funds from your Issuing Balance

1. Sign up for a [Stripe account](https://dashboard.stripe.com/register).
1. [Activate Issuing](https://dashboard.stripe.com/issuing/activate) in a *sandbox* environment from the Dashboard.

## Add funds

To spend money using cards, add funds to the Issuing balance on your account. This balance represents funds reserved for Issuing and is safely separated from your earnings, payouts, and funds from other Stripe products.

You can add funds from your [Dashboard](https://dashboard.stripe.com/balance/overview#issuing-summary) or using the [create top-up](https://docs.stripe.com/api/topups/create.md) endpoint.

```bash
curl https://api.stripe.com/v1/topups \
  -u <<secret key>>: \
  -d destination_balance=issuing \
  -d amount=2000 \
  -d currency=usd \
  -d description="Top-up for Issuing, " \
  -d statement_descriptor=Top-up
```

```ruby
<<setup key>>

topup = Stripe::Topup.create({
  destination_balance: 'issuing',
  amount: 2000,
  currency: 'usd',
  description: "Top-up for Issuing, ",
  statement_descriptor: 'Top-up',
})
```

```python
<<setup key>>

topup = stripe.Topup.create(
    destination_balance='issuing',
    amount=2000,
    currency='usd',
    description="Top-up for Issuing, ",
    statement_descriptor='Top-up',
)
```

```php
<<setup key>>

$topup = \Stripe\Topup::create([
    'destination_balance' => 'issuing',
    'amount' => 2000,
    'currency' => 'usd',
    'description' => "Top-up for Issuing, ",
    'statement_descriptor' => 'Top-up',
]);
```

```java
<<setup key>>

TopupCreateParams params =
  TopupCreateParams.builder()
    .putExtraParam("destination_balance", "issuing")
    .setAmount(2000L)
    .setCurrency("usd")
    .setDescription("Top-up for Issuing, ")
    .setStatementDescriptor("Top-up")
    .build();

Topup topup = Topup.create(params);
```

```javascript
<<setup key>>

const topup = await stripe.topups.create({
  destination_balance: 'issuing',
  amount: 2000,
  currency: 'usd',
  description: "Top-up for Issuing, ",
  statement_descriptor: 'Top-up',
});
```

```go
<<setup key>>

params := &stripe.TopupParams{
  Amount:              stripe.Int64(2000),
  Currency:            stripe.String(string(stripe.CurrencyUSD)),
  Description:         stripe.String("Top-up for Issuing, "),
  StatementDescriptor: stripe.String("Top-up"),
}
params.AddExtra("destination_balance", "issuing")

tu, _ := topup.New(params)
```

```dotnet
<<setup key>>

var options = new TopupCreateOptions
{
  Amount = 2000,
  Currency = "usd",
  Description = "Top-up for Issuing, ",
  StatementDescriptor = "Top-up",
};

options.AddExtraParam("destination_balance", "issuing");
var service = new TopupService();
service.Create(options);
```

## Create cardholders and cards

### Create a cardholder 

Stripe returns a `Cardholder` object that contains the information you provided and sends the `issuing_cardholder.created` webhook event.

### Create a card 

In the following examples, we show you how to create a [virtual card](https://docs.stripe.com/issuing/cards/virtual.md). You can, however, create [physical cards](https://docs.stripe.com/issuing/cards/physical.md) and ship them to cardholders in live mode.

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

var options = new Stripe.Issuing.CardCreateOptions
{
    Currency = "usd",
    Type = "virtual",
    Cardholder = "<<issuingCardholder>>",
};
var service = new Stripe.Issuing.CardService();
Stripe.Issuing.Card card = service.Create(options);
```

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

params := &stripe.IssuingCardParams{
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  Type: stripe.String(string(stripe.IssuingCardTypeVirtual)),
  Cardholder: stripe.String("<<issuingCardholder>>"),
};
result, err := card.New(params);
```

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

CardCreateParams params =
  CardCreateParams.builder()
    .setCurrency("usd")
    .setType(CardCreateParams.Type.VIRTUAL)
    .setCardholder("<<issuingCardholder>>")
    .build();

Card card = Card.create(params);
```

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

const card = await stripe.issuing.cards.create({
  currency: 'usd',
  type: 'virtual',
  cardholder: '<<issuingCardholder>>',
});
```

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

card =
stripe.issuing.Card.create(
  currency="usd",
  type="virtual",
  cardholder="<<issuingCardholder>>",
)
```

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

$card = $stripe->issuing->cards->create([
  'currency' => 'usd',
  'type' => 'virtual',
  'cardholder' => '<<issuingCardholder>>',
]);
```

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

card = Stripe::Issuing::Card.create({
  currency: 'usd',
  type: 'virtual',
  cardholder: '<<issuingCardholder>>',
})
```

Stripe returns a `Card` object on creation, and sends the `issuing_card.created` webhook event:

```json
{
  "id": "ic_1NvPjF2SSJdH5vn2OVbE7r0b",
  "object": "issuing.card",
  "brand": "Visa",
  ...
  "status": "inactive",
  "type": "virtual"
}
```

You need to activate the card before a user can use it. While you can activate virtual cards in the same API call you used to create it, you must activate physical cards separately. When ready, activate the card by marking the `status` as `active`:

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

var options = new Stripe.Issuing.CardUpdateOptions { Status = "active" };
var service = new Stripe.Issuing.CardService();
Stripe.Issuing.Card card = service.Update("ic_1NvPjF2SSJdH5vn2OVbE7r0b", options);
```

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

params := &stripe.IssuingCardParams{Status: stripe.String(string(stripe.IssuingCardStatusActive))};
result, err := card.Update("ic_1NvPjF2SSJdH5vn2OVbE7r0b", params);
```

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

Card resource = Card.retrieve("ic_1NvPjF2SSJdH5vn2OVbE7r0b");

CardUpdateParams params =
  CardUpdateParams.builder().setStatus(CardUpdateParams.Status.ACTIVE).build();

Card card = resource.update(params);
```

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

const card = await stripe.issuing.cards.update(
  'ic_1NvPjF2SSJdH5vn2OVbE7r0b',
  {
    status: 'active',
  }
);
```

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

card =
stripe.issuing.Card.modify(
  "ic_1NvPjF2SSJdH5vn2OVbE7r0b",
  status="active",
)
```

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

$card = $stripe->issuing->cards->update('ic_1NvPjF2SSJdH5vn2OVbE7r0b', ['status' => 'active']);
```

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

card = Stripe::Issuing::Card.update('ic_1NvPjF2SSJdH5vn2OVbE7r0b', {status: 'active'})
```

```json
{
  "id": "ic_1NvPjF2SSJdH5vn2OVbE7r0b",
  "object": "issuing.card",
  "brand": "Visa",
  ...
  "status": "active",
  "type": "virtual",
}
```

To learn more, see:

- [Virtual cards](https://docs.stripe.com/issuing/cards/virtual.md)
- [Physical cards](https://docs.stripe.com/issuing/cards/physical.md)
- [Use the Dashboard for Issuing with Connect](https://docs.stripe.com/issuing/connect.md#using-dashboard-issuing)
- [Create cards with the API](https://docs.stripe.com/api/issuing/cards.md)

## Use the card

### Create an authorization 

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

var options = new Stripe.TestHelpers.Issuing.AuthorizationCreateOptions
{
    Card = "<<issuingCard>>",
    Amount = 1000,
    AuthorizationMethod = "chip",
    MerchantData = new Stripe.TestHelpers.Issuing.AuthorizationMerchantDataOptions
    {
        Category = "taxicabs_limousines",
        City = "San Francisco",
        Country = "US",
        Name = "Rocket Rides",
        NetworkId = "1234567890",
        PostalCode = "94107",
        State = "CA",
    },
};
var service = new Stripe.TestHelpers.Issuing.AuthorizationService();
Stripe.Issuing.Authorization authorization = service.Create(options);
```

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

params := &stripe.TestHelpersIssuingAuthorizationParams{
  Card: stripe.String("<<issuingCard>>"),
  Amount: stripe.Int64(1000),
  AuthorizationMethod: stripe.String(string(stripe.IssuingAuthorizationAuthorizationMethodChip)),
  MerchantData: &stripe.TestHelpersIssuingAuthorizationMerchantDataParams{
    Category: stripe.String("taxicabs_limousines"),
    City: stripe.String("San Francisco"),
    Country: stripe.String("US"),
    Name: stripe.String("Rocket Rides"),
    NetworkID: stripe.String("1234567890"),
    PostalCode: stripe.String("94107"),
    State: stripe.String("CA"),
  },
};
result, err := authorization.New(params);
```

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

AuthorizationCreateParams params =
  AuthorizationCreateParams.builder()
    .setCard("<<issuingCard>>")
    .setAmount(1000L)
    .setAuthorizationMethod(AuthorizationCreateParams.AuthorizationMethod.CHIP)
    .setMerchantData(
      AuthorizationCreateParams.MerchantData.builder()
        .setCategory(AuthorizationCreateParams.MerchantData.Category.TAXICABS_LIMOUSINES)
        .setCity("San Francisco")
        .setCountry("US")
        .setName("Rocket Rides")
        .setNetworkId("1234567890")
        .setPostalCode("94107")
        .setState("CA")
        .build()
    )
    .build();

Authorization authorization = Authorization.TestHelpers.create(params);
```

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

const authorization = await stripe.testHelpers.issuing.authorizations.create({
  card: '<<issuingCard>>',
  amount: 1000,
  authorization_method: 'chip',
  merchant_data: {
    category: 'taxicabs_limousines',
    city: 'San Francisco',
    country: 'US',
    name: 'Rocket Rides',
    network_id: '1234567890',
    postal_code: '94107',
    state: 'CA',
  },
});
```

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

authorization =
stripe.issuing.Authorization.TestHelpers.create(
  card="<<issuingCard>>",
  amount=1000,
  authorization_method="chip",
  merchant_data={
    "category": "taxicabs_limousines",
    "city": "San Francisco",
    "country": "US",
    "name": "Rocket Rides",
    "network_id": "1234567890",
    "postal_code": "94107",
    "state": "CA",
  },
)
```

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

$authorization = $stripe->testHelpers->issuing->authorizations->create([
  'card' => '<<issuingCard>>',
  'amount' => 1000,
  'authorization_method' => 'chip',
  'merchant_data' => [
    'category' => 'taxicabs_limousines',
    'city' => 'San Francisco',
    'country' => 'US',
    'name' => 'Rocket Rides',
    'network_id' => '1234567890',
    'postal_code' => '94107',
    'state' => 'CA',
  ],
]);
```

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

authorization = Stripe::Issuing::Authorization::TestHelpers.create({
  card: '<<issuingCard>>',
  amount: 1000,
  authorization_method: 'chip',
  merchant_data: {
    category: 'taxicabs_limousines',
    city: 'San Francisco',
    country: 'US',
    name: 'Rocket Rides',
    network_id: '1234567890',
    postal_code: '94107',
    state: 'CA',
  },
})
```

After approval, Stripe creates an `Authorization` in a `pending` state while it waits for [capture](https://docs.stripe.com/issuing/purchases/transactions.md). Note the authorization `id` that you’ll use to capture the funds:

```json
{
  "id": "iauth_1NvPyY2SSJdH5vn2xZQE8C7k",
  "object": "issuing.authorization",
  "amount": 1000,
  ...
  "status": "pending",
  "transactions": [],
}
```

### Capture the funds 

Capture the funds using the following code:

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

var service = new Stripe.TestHelpers.Issuing.AuthorizationService();
Stripe.Issuing.Authorization authorization = service.Capture("<<issuingAuthorization>>");
```

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

params := &stripe.TestHelpersIssuingAuthorizationCaptureParams{};
result, err := authorization.Capture("<<issuingAuthorization>>", params);
```

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

Authorization resource = Authorization.retrieve("<<issuingAuthorization>>");

AuthorizationCaptureParams params = AuthorizationCaptureParams.builder().build();

Authorization authorization = resource.getTestHelpers().capture(params);
```

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

const authorization = await stripe.testHelpers.issuing.authorizations.capture(
  '<<issuingAuthorization>>'
);
```

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

authorization =
stripe.issuing.Authorization.TestHelpers.capture("<<issuingAuthorization>>")
```

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

$authorization = $stripe->testHelpers->issuing->authorizations->capture(
  '<<issuingAuthorization>>',
  []
);
```

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

authorization = Stripe::Issuing::Authorization::TestHelpers.capture('<<issuingAuthorization>>')
```

## See Also

- [Handling real-time auth webhooks](https://docs.stripe.com/issuing/controls/real-time-authorizations.md)
- [Spending controls](https://docs.stripe.com/issuing/controls/spending-controls.md)
- [Issuing authorizations](https://docs.stripe.com/issuing/purchases/authorizations.md)
- [Issuing transactions](https://docs.stripe.com/issuing/purchases/transactions.md)
- [Testing Issuing](https://docs.stripe.com/issuing/testing.md)
- [Working with Stripe Issuing cards and Treasury](https://docs.stripe.com/treasury/account-management/issuing-cards.md)
- [Manage transaction fraud](https://docs.stripe.com/issuing/manage-fraud.md)
- [Issue regulated customer notices](https://docs.stripe.com/issuing/compliance-us/issuing-regulated-customer-notices.md)