# Integrate Consumer Credit Issuing

Use Consumer Credit Issuing to launch a credit program for your customers.

Create a bank-sponsored credit program that lets you onboard consumers, issue cards, manage repayments, and handle disputes.

## Set up a sandbox

Before using Consumer Credit Issuing in production, test it in a [sandbox](https://docs.stripe.com/sandboxes.md):

1. When you create a Stripe account, click **Go to sandbox**.
2. Go to the [Connect](https://dashboard.stripe.com/connect) page in the Stripe Dashboard.
3. Click **Get started**, then click **Continue setup**.
4. Select **Platform** as your business model, then click **Use the Accounts v1 API instead**.
5. Click **Start testing**, then click **Create test account** and create your test account.
6. In the top left corner, click your platform’s name, then click **Exit sandbox**.
7. Email your Stripe representative the account ID of your sandbox account and live account. To find the account IDs:
   - Sandbox account ID: Go to **Settings** > **Business**. Copy the account ID.
   - Live account ID: Go to **Settings** > **Personal Details**, and in the **Accounts** section, copy the account ID.

## Set up your platform

To set up your platform with Stripe:

1. Retrieve your issuing program ID.
2. Upload the terms of service (TOS) for your issuing program.
3. Using your issuing program ID, set the TOS for your issuing program.

### Retrieve your issuing program ID

```curl
curl https://api.stripe.com/v1/issuing/programs \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_program_beta=v2"
```

Use the `id` value from the response as the `ISSUING_PROGRAM_ID` in later steps.

Example response:

```json
{
    "object": "list",
    "data": [
        {
            "id": "iprg_1QubMYHc09eLP8enVnw6Aswz",
            "object": "issuing.program",
            "brand": "visa",
            "capability": "card_issuing_consumer_revolving_credit_card_celtic",
            ...
        }
    ],
    "has_more": false,
    "url": "/v1/issuing/programs"
}
```

### Upload TOS

```curl
curl https://files.stripe.com/v1/files \
  -u "{{SECRET_KEY}}:" \
  -F "purpose"="platform_terms_of_service" \
  -F "file"="@/path/to/a/file.pdf"
```

Use the `id` value from the response as the `FILE_ID` when setting TOS for your issuing program.

Example response:

```json
{
    "id": "file_1SPXMDHc09eLP8enFkiWcPNS",
    "object": "file",
    "created": 1762213217,
    "expires_at": null,
    "filename": "tos.pdf",
    ...
    "purpose": "platform_terms_of_service",
   ...
}
```

### Set the TOS for your issuing program

```curl
curl https://api.stripe.com/v1/issuing/programs/{{PROGRAMID_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_program_beta=v2" \
  -d "platform_terms_of_service={{FILE_ID}}"
```

## Onboard consumers

To onboard a consumer to your credit program, create a connected account for them, collect their [KYC information](https://docs.stripe.com/issuing/consumer-issuing/integrate.md#collect-kyc-information), run [underwriting](https://docs.stripe.com/issuing/consumer-issuing/integrate.md#initiate-underwriting), and activate their [credit policy](https://docs.stripe.com/issuing/consumer-issuing/integrate.md#activate-the-credit-policy).

### Create a connected account

Create a Custom connected account for the consumer:

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d country=US \
  -d "capabilities[transfers][requested]=true" \
  -d "controller[stripe_dashboard][type]=none" \
  -d "controller[fees][payer]=application" \
  -d "controller[losses][payments]=application" \
  -d "controller[requirement_collection]=application" \
  -d business_type=individual \
  -d "business_profile[mcc]=5999" \
  --data-urlencode "business_profile[url]=https://www.example.com"
```

For `business_profile`, replace `https://www.example.com` with your platform’s URL. The MCC `5999` is the standard default for general-purpose consumer credit cards. You can use a more specific code for your platform’s vertical. See [Merchant categories](https://docs.stripe.com/issuing/categories.md) for the full list.

Next, create an [issuing program](https://docs.stripe.com/issuing/cards/beta/programs.md) on the connected account using the platform issuing program ID you retrieved in the previous section:

```curl
curl https://api.stripe.com/v1/issuing/programs \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_program_beta=v2" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "platform_program={{PROGRAMID_ID}}" \
  -d is_default=true
```

### Collect KYC information

Collect the consumer’s personal information and submit it to the account.

Stripe attempts to verify the consumer’s identity using their name, date of birth, and SSN. See [Handle identity verification](https://docs.stripe.com/connect/handling-api-verification.md#handle-identity-verification) for instructions about implementing this flow. Use the below endpoint to submit the required information. If programmatic verification isn’t possible, Stripe returns a requirement to upload a government ID.

```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTEDACCOUNT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_program_beta=v2" \
  --data-urlencode "email=jenny.rosen@example.com" \
  -d "business_profile[name]=Jenny Rosen" \
  -d "individual[first_name]=Jenny" \
  -d "individual[last_name]=Rosen" \
  -d "individual[dob][day]=1" \
  -d "individual[dob][month]=11" \
  -d "individual[dob][year]=1981" \
  -d "individual[address][line1]=123 Main Street" \
  -d "individual[address][city]=San Francisco" \
  -d "individual[address][state]=CA" \
  -d "individual[address][postal_code]=94111" \
  -d "individual[address][country]=US" \
  --data-urlencode "individual[email]=jenny.rosen@example.com" \
  -d "individual[phone]=111-222-3333" \
  -d "individual[ssn_last_4]=0000" \
  -d "individual[self_reported_income][amount]=5000" \
  -d "individual[self_reported_income][currency]=usd" \
  -d "individual[self_reported_monthly_housing_payment][amount]=1000" \
  -d "individual[self_reported_monthly_housing_payment][currency]=usd"
```

> `individual[self_reported_monthly_housing_payment]` is only required if the consumer rents their home.

The connected account now has the KYC requirements for Consumer Credit Issuing. You can view them by retrieving the account.

### Report the credit decision

> This step applies to BYO underwriting integrations only. For hosted underwriting, go to [Initiate underwriting](https://docs.stripe.com/issuing/consumer-issuing/integrate.md#initiate-underwriting).

Create a credit underwriting record for the consumer’s application:

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_application \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "application[purpose]=credit_line_opening" \
  -d "application[submitted_at]=1687656783" \
  -d "credit_user[name]=Jenny Rosen" \
  --data-urlencode "credit_user[email]=jenny.rosen@example.com"
```

Then report the decision using the credit underwriting record ID from the response:

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/{{CREDITUNDERWRITINGRECORD_ID}}/report_decision \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d decided_at=1687742400 \
  -d "decision[type]=credit_limit_approved" \
  -d "decision[credit_limit_approved][amount]=100000" \
  -d "decision[credit_limit_approved][currency]=usd" \
  -d "decision[credit_limit_approved][consumer_revolving_credit][annual_percentage_rates][0][type]=purchase" \
  -d "decision[credit_limit_approved][consumer_revolving_credit][annual_percentage_rates][0][apr_type]=margin_on_us_prime_rate" \
  -d "decision[credit_limit_approved][consumer_revolving_credit][annual_percentage_rates][0][margin_percentage]=2.5"
```

Negative decisions require Adverse Action Notices. Use the [no-code solution](https://docs.stripe.com/issuing/credit/report-credit-decisions-and-manage-aans.md#sending-adverse-action-notice-emails) to send them automatically.

### Initiate underwriting

> This step applies to Hosted Underwriting integrations only. For BYO Underwriting, go to [Collect terms of service acceptance](https://docs.stripe.com/issuing/consumer-issuing/integrate.md#collect-tos-acceptance).

Submit the consumer’s application to Stripe for underwriting:

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_application \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "application[purpose]=credit_line_opening" \
  -d "application[submitted_at]=1687656783" \
  -d "credit_user[name]=Jenny Rosen" \
  --data-urlencode "credit_user[email]=jenny.rosen@example.com" \
  -d underwriting_policy={{UNDERWRITING_POLICY_ID}}
```

Stripe sends an [issuing.credit_underwriting_record.updated](https://docs.stripe.com/api/events/types.md#event_types-issuing.credit_underwriting_record.updated) webhook with the result. Check for `application.state: pre_approval` and a non-null `decision.credit_limit_approved` to confirm the consumer is pre-approved before proceeding to collect Terms of Service acceptance.

### Collect Terms of Service acceptance 

Present the consumer with the approved credit limit, APR, and final terms of service. After they accept, record it on the account.

For hosted underwriting integrations, Stripe performs the hard credit pull after TOS acceptance and sends an `issuing.credit_underwriting_record.updated` webhook confirming the result.

```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTEDACCOUNT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_program_beta=v2" \
  -d "tos_acceptance[date]=1768908001" \
  -d "tos_acceptance[ip]=192.168.123.132" \
  -d "settings[card_issuing][tos_acceptances][account_holder][date]=1768908001" \
  -d "settings[card_issuing][tos_acceptances][account_holder][ip]=192.168.123.132" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic][date]=1761769098" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic][ip]=192.168.123.132" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_platform][date]=1761769098" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_platform][ip]=192.168.123.132" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_privacy_notice][date]=1761769098" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_privacy_notice][ip]=192.168.123.132" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_privacy_notice_platform][date]=1761769098" \
  -d "settings[card_issuing][tos_acceptances][consumer_revolving_credit_card_celtic_privacy_notice_platform][ip]=192.168.123.132"
```

### Activate the credit policy

Retrieve the consumer’s credit policy ID:

```curl
curl https://api.stripe.com/v1/issuing/credit_policies \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

Then activate it with the approved credit limit and billing cycle:

```curl
curl https://api.stripe.com/v1/issuing/credit_policies/{{CREDIT_POLICY_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d credit_limit_amount=100000 \
  -d credit_limit_currency=usd \
  -d credit_period_interval=month \
  -d credit_period_interval_count=1 \
  -d "credit_period_ends_on_days[]=15" \
  -d days_until_due=25 \
  -d status=active
```

### Test hosted underwriting

You can test different scenarios in your hosted underwriting flow by using a special first name for the consumer. Replace `individual[first_name]` with one of the magic strings listed below.

| Magic string | Scenario |
| --- | --- |
| `frozen_file_at_credit_bureau` | Credit report returns a frozen file. |
| `final_approval_frozen_file_at_credit_bureau` | The consumer is initially pre-approved and accepts the Terms of Service, but is rejected when the hard credit pull reveals a credit freeze. |
| `alert_final_approval_initial_fraud_phone` | A hard pull detects a fraud alert and Stripe has the consumer’s phone number on record. |
| `alert_final_approval_initial_fraud_no_phone` | A hard pull detects a fraud alert and Stripe doesn’t have the consumer’s phone number on record. |
| `alert_final_approval_extended_fraud_phone` | An extended fraud alert during final approval. Stripe contacts the consumer by phone. |
| `alert_final_approval_extended_fraud_no_phone` | An extended fraud alert during final approval. Stripe contacts the consumer by email. |
| `alert_pre_approval_initial_fraud_phone` | A soft pull finds a fraud alert and Stripe has the consumer’s phone number. |
| `alert_pre_approval_initial_fraud_no_phone` | A soft pull finds a fraud alert and Stripe doesn’t have the consumer’s phone number. |
| `alert_pre_approval_extended_fraud_phone` | An extended fraud alert during pre-approval. Stripe contacts the consumer by phone. |
| `alert_pre_approval_extended_fraud_no_phone` | An extended fraud alert during pre-approval. Stripe contacts the consumer by email. |

```curl
curl https://api.stripe.com/v1/accounts/{{CONNECTED_ACCOUNT_ID}} \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Version: 2025-01-27.acacia; issuing_program_beta=v2" \
  -d "email"="jenny.rosen@example.com" \
  -d "individual[first_name]"="{{HOSTED_UNDERWRITING_MAGIC_STRING}}" \
  -d "individual[last_name]"="Rosen" \
  -d "individual[dob][day]"=1 \
  -d "individual[dob][month]"=11 \
  -d "individual[dob][year]"=1981 \
  -d "individual[address][line1]"="123 Main Street" \
  -d "individual[address][city]"="San Francisco" \
  -d "individual[address][state]"="CA" \
  -d "individual[address][postal_code]"="94111" \
  -d "individual[address][country]"="US" \
  -d "individual[email]"="jenny.rosen@example.com" \
  -d "individual[phone]"="111-222-3333" \
  -d "individual[ssn_last_4]"="0000" \
  -d "individual[self_reported_income][amount]"="0000" \
  -d "individual[self_reported_income][currency]"="usd" \
  -d "individual[self_reported_monthly_housing_payment][amount]"="000" \
  -d "individual[self_reported_monthly_housing_payment][currency]"="usd"
```

When you initiate consumer underwriting in the next step, set `underwriting_policy` to any value.

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_application \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -d "application[purpose]"=credit_line_opening \
  -d "application[submitted_at]"=1687656783 \
  -d "credit_user[name]"="Jenny Rosen" \
  --data-urlencode "credit_user[email]"="jenny.rosen@example.com" \
  -d "underwriting_policy"=mock_policy_id
```

### Suspend a credit policy

Platforms can suspend a cardholder’s credit policy for suspected fraud pending investigation. All changes to credit policy status require a supporting credit underwriting record.

First, create a credit underwriting record for suspension:

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_proactive_review \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "credit_user[name]=Jenny Rosen" \
  --data-urlencode "credit_user[email]=jenny.rosen@example.com" \
  -d decided_at=1759332619 \
  -d "decision[type]=credit_line_suspended" \
  -d "decision[credit_line_suspended][reasons][]=suspected_fraud_pending_investigation"
```

Next, change the credit policy’s status to suspended with a supporting status reason of suspected fraud pending investigation.

Use the cardholder’s credit policy ID, and the credit underwriting record ID obtained in the previous step.

```curl
curl https://api.stripe.com/v1/issuing/credit_policies/{{CREDIT_POLICY_ID}} \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -H "Stripe-Version: issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -d status=suspended \
  -d "status_reasons[platform_controlled][][type]=suspected_fraud_pending_investigation" \
  -d "status_reasons[platform_controlled][][from_credit_underwriting_record]={{CREDIT_UNDERWRITING_RECORD_ID}}"
```

### Lift suspension on a credit policy

Platforms might lift suspension on a cardholder’s credit policy if they’re removing the last platform_controlled suspension `status_reason`, and no other status reasons, whether platform-controlled or stripe-controlled, are present.

For example, platforms can suspend a credit policy for suspected fraud and later lift that suspension. However, if the account also goes delinquent while suspended, the platform can remove their fraud-related suspension status reason, but can’t transition the credit policy back to active.

First, create a credit underwriting record to lift the platform-controlled suspension:

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_proactive_review \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "credit_user[name]=Jenny Rosen" \
  --data-urlencode "credit_user[email]=jenny.rosen@example.com" \
  -d decided_at=1759332619 \
  -d "decision[type]=suspension_reasons_lifted" \
  -d "decision[suspension_reasons_lifted][reasons][]=suspected_fraud_pending_investigation"
```

Next, transition the credit policy back to active.

In this case, the credit underwriting record ID isn’t needed. The call works if the credit underwriting record was created first. Additionally, you don’t have to indicate removal of the status reason through API parameters.

Use the cardholder’s credit policy ID.

```curl
curl https://api.stripe.com/v1/issuing/credit_policies/{{CREDIT_POLICY_ID}} \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -H "Stripe-Version: issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -d status=active \
  -d "status_reasons[platform_controlled]="
```

### Close a credit policy

Platforms can permanently close a cardholder’s credit policy for suspected fraud or terms of service violations.

All changes to credit policy status require a supporting credit underwriting record.

First, create a credit underwriting record for closure. Valid `credit_line_closed` reasons include `suspected_fraud` or `terms_of_use_violation`.

```curl
curl https://api.stripe.com/v1/issuing/credit_underwriting_records/create_from_proactive_review \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d "credit_user[name]=Jenny Rosen" \
  --data-urlencode "credit_user[email]=jenny.rosen@example.com" \
  -d decided_at=1759332619 \
  -d "decision[type]=credit_line_closed" \
  -d "decision[credit_line_closed][reasons][]=suspected_fraud"
```

Next, change the credit policy’s status to `permanently_closed` with the proper supporting status reason.

Valid status reason type enums include `suspected_fraud` and `tos_violation`.

Use the cardholder’s credit policy ID, and the credit underwriting record ID obtained in the previous step.

```curl
curl https://api.stripe.com/v1/issuing/credit_policies/{{CREDIT_POLICY_ID}} \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -H "Stripe-Version: issuing_credit_beta=v3; issuing_underwritten_credit_beta=v1" \
  -d status=permanently_closed \
  -d "status_reasons[platform_controlled][][type]=suspected_fraud" \
  -d "status_reasons[platform_controlled][][from_credit_underwriting_record]={{CREDIT_UNDERWRITING_RECORD_ID}}"
```

### Set up payment method for accepting repayments

If you use Stripe to collect repayments, collect bank account details and configure a Customer and Payment Method.

First, create a Stripe bank account token from the cardholder’s bank account. [Collect the consumer’s authorization](https://docs.stripe.com/payments/ach-direct-debit.md#mandates) to perform an ACH direct debit. Alternatively, use [Stripe Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) where Stripe requests authorization.

Next, create a `Customer` object on your platform account to save the payment method for reuse. Store the connected account ID in the customer’s metadata to link the customer back to the consumer.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "name=Jenny Rosen" \
  -d "metadata[user_id]=acct_123" \
  --data-urlencode "email=jenny.rosen@example.com"
```

Next, update the metadata on the connected account to point to the `Customer` object.

```curl
curl https://api.stripe.com/v1/accounts/acct_123 \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "metadata[customer_id]=cus_NffrFeUfNV2Hib"
```

Then create a SetupIntent to prepare for later payments.

```curl
curl https://api.stripe.com/v1/setup_intents \
  -u "{{SECRET_KEY}}:" \
  -d "payment_method_types[]"=us_bank_account \
  -d customer={{CUSTOMER_ID}} \
  -d "payment_method_data[type]"=us_bank_account \
  -d "payment_method_data[us_bank_account][token]"={{stripe_bank_account_token}} \
  -d "payment_method_data[billing_details][name]"={{CUSTOMER_NAME}} \
  -d metadata[user_id]={{CUSTOMER_ID.metadata.user_id}}
```

Save the PaymentMethod from the response. You’ll use it to create repayments.

Finally, confirm the SetupIntent.

```curl
curl -X POST https://api.stripe.com/v1/setup_intents/{{SETUP_INTENT_ID}}/confirm \
  -u "{{SECRET_KEY}}:" \
  -d "payment_method"="{{PAYMENT_METHOD_ID_FROM_ABOVE}}" \
  -d "mandate_data[customer_acceptance][type]"="online" \
  -d "mandate_data[customer_acceptance][online][ip_address]"="<consumer IP address>" \
  -d "mandate_data[customer_acceptance][online][user_agent]"="<consumer user agent such as browser info>"
```

## Issue a card

To issue a card, follow these guides. You can also [add cards to digital wallets](https://docs.stripe.com/issuing/cards/digital-wallets.md).

- [Design a card](https://docs.stripe.com/issuing/cards/physical/create-design.md)
  - Choose a design bundle
  - Go through design review
- [Issue a physical card](https://docs.stripe.com/issuing/cards/physical/issue-cards.md)
  - Create a cardholder
  - Create a card
  - Activate a card

You can also enable [spend controls](https://docs.stripe.com/issuing/controls/spending-controls.md). Spend controls let you configure spend limits on cards and cardholders, such as the max amount for specific types of businesses per day. If no spend limits are configured when creating a card, Stripe implements a 500 USD daily spend limit by default as a layer of protection.

If a physical card is lost or expires, you can [replace it](https://docs.stripe.com/issuing/cards/replacements.md).

## Fund the cards

The funds flow uses three balances:

- **Consumer (CA) Issuing Balance/Credit Ledger**: The Credit Ledger tracks a consumer’s obligations to the platform. The related Issuing Balance ensures compliant funds flows between platforms and consumers, and is 0 USD in steady state.
- **Platform Issuing Balance/Funding Obligation**: The Platform Funding Obligation tracks the platform’s obligations to Stripe (to be post-funded). The related Issuing Balance receives post-funding funds from the platform.
- **Platform Issuing Reserve**: This is a special balance that Stripe draws from only if repayment for platform obligations is overdue. Drawing from the reserve affects credit limits and might affect authorizations.

Learn how to [manage your Platform Issuing Reserve](https://docs.stripe.com/issuing/funding/post-fund.md#reserve).

### Authorization

[Approve or decline the authorization](https://docs.stripe.com/issuing/controls/real-time-authorizations.md), then process the issuing authorization notification. When Stripe processes an Issuing authorization, it sends an `issuing_authorization.created` webhook. The authorization is available in the Issuing Authorization API. Stripe sends an `issuing_transaction.created` webhook when it processes a capture, which includes the final amount actually captured for an authorization.

### Manage post-funding

The diagram below shows the main integration points to post-fund consumer card spend.
![Diagram showing the different integration points for post-funding consumer card spend](https://b.stripecdn.com/docs-statics-srv/assets/cci-post-funding.e45b844649e23da1e5a7255139cd356b.png)

### Settlement

Stripe sends an `issuing_funding_obligation.updated` webhook for each FundingObligation update (a record of the platform’s obligation to Stripe) each day. When a funding obligation’s status transitions to `unpaid`, the amount is final and ready for repayment.

To confirm the platform obligation amount, call the FundingObligations API to list obligations. Obligations that are in states of `unpaid` and `past_due` need to be paid.

```curl
curl -G https://api.stripe.com/v1/issuing/funding_obligations \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3" \
  -d limit=3
```

Example response:

```json
{
  "object": "list",
  "url": "/v1/issuing/funding_obligations",
  "has_more": false,
  "data": [
    {
      "id": "ifo_123",
      "object": "issuing.funding_obligation",
      "amount_outstanding": 9000,
      "amount_paid": 1000,
      "amount_total": 10000,
      "created": 1695774374,
      "credit_period_ends_at": 1695859199,
      "credit_period_starts_at": 1695772800,
      "currency": "usd",
      "due_at": 1695859199,
      "owed_to": "stripe",
      "status": "pending",
      "transaction_period_ends_at": 1695823200,
      "transaction_period_starts_at": 1695736860,
      ...
    }
  ]
}
```

To retrieve bank account details for wiring funds to Stripe, call the Funding Instructions API:

```curl
curl https://api.stripe.com/v1/issuing/funding_instructions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "bank_transfer[type]=us_bank_transfer" \
  -d currency=usd \
  -d funding_type=bank_transfer
```

## Issue rewards

To record a reward on a consumer’s credit ledger, first retrieve the consumer’s current pending funding obligation, then create a credit ledger adjustment:

```curl
curl -G https://api.stripe.com/v1/issuing/funding_obligations \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d status=pending
```

```curl
curl https://api.stripe.com/v1/issuing/credit_ledger_adjustments \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d amount_type=credit \
  -d amount=5000 \
  -d currency=usd \
  -d reason=platform_issued_credit_memo \
  -d "reason_description=Customer loyalty reward credited to account" \
  -d "funding_obligation={{FUNDINGOBLIGATION_ID}}"
```

You can also use credit ledger adjustments to make other corrections to a consumer’s credit ledger. For debits, use `reason=platform_issued_debit_memo` and set `amount_type` to `"debit"`.

## Display account information

### Show available balance

Retrieve the consumer’s credit ledger to show their current available credit, statement balance, and payment status:

```curl
curl https://api.stripe.com/v1/issuing/credit_ledger \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

Example response:

```json
{
  "credit_limit": 100000,
  "amount_pending": 10000,
  "obligations": {
    "accruing": 5000,
    "unpaid": 15000
  },
  "credit_available": 70000,
  "currency": "usd",
  "statement_balance": 15150,
  "minimum_payment_amount": 5000,
  "due_at": 12345678,
  "remaining_minimum_payment": 100,
  "remaining_statement_balance": 10250,
  "payment_status": "good_standing"
}
```

### List transactions

List credit ledger entries to show a consumer’s transaction history. Optionally filter by a specific credit statement:

```curl
curl -G https://api.stripe.com/v1/issuing/credit_ledger_entries \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v3" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d credit_statement=cs_123
```

To retrieve additional detail about each entry, call the API corresponding to its `source.type`:

- For `issuing_transaction`, call the [Issuing Transaction API](https://docs.stripe.com/api/issuing/transactions/retrieve.md). If the transaction has an associated authorization, [retrieve the authorization](https://docs.stripe.com/api/issuing/authorizations/retrieve.md) for enriched merchant data.
- For `issuing_credit_ledger_adjustment`, call the `/v1/issuing/credit_ledger_adjustments` API.

### View statements

Stripe sends an `issuing_credit_statement.finalized` webhook when a billing statement is generated. The webhook includes a `statement_pdf` URL for the statement PDF.

To list all finalized statements for a consumer:

```curl
curl https://api.stripe.com/v1/issuing/credit_statements \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

To retrieve the current (not yet finalized) statement:

```curl
curl https://api.stripe.com/v1/issuing/credit_statements/current \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

To generate an unauthenticated download link for a statement PDF, create a [file link](https://docs.stripe.com/api/file_links/create.md) using the `file` ID from the statement object.

#### Test statements

To test statements in test mode, create backdated transactions using the test helper APIs. Create a new connected account for each scenario you want to test, because backdated transactions can only be created before any statements are finalized for a line of credit.

```curl
curl -X POST https://api.stripe.com/v1/test_helpers/issuing/transactions/create_force_capture \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -H "Stripe-Version: 2025-03-31.basil; issuing_credit_beta=v3" \
  -d card={{CARD_ID}} \
  -d currency=usd \
  -d amount=1500 \
  -d effective_date=2025-10-01
```

After creating backdated transactions, re-enable statement generation for the credit policy:

```curl
curl -X POST https://api.stripe.com/v1/test_helpers/issuing/credit_policies/{{CREDIT_POLICY_ID}}/enable_statement_generation \
  -u "{{SECRET_KEY}}:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -H "Stripe-Version: 2025-03-31.basil; issuing_credit_beta=v3"
```

Stripe sends `issuing_credit_statement.created` and `issuing_credit_statement.finalized` webhooks for each backdated statement period.

### View finance charges

List finance charges (interest and fees) applied to a consumer’s credit account:

```curl
curl https://api.stripe.com/v1/issuing/credit_ledger_finance_charges \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; issuing_credit_beta=v4" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

Example response:

```json
{
  "object": "list",
  "data": [
    {
      "id": "iflfc_123",
      "object": "issuing.credit_ledger_finance_charge",
      "amount": 100,
      "applied_to_ledger_at": 1773532800,
      "currency": "usd",
      "description": "Interest charge",
      "type": "interest"
    }
  ]
}
```

Finance charge types include `interest`, `interest_adjustment`, `late_fee`, `platform_initiated_fee`, and `returned_payment_fee`. Negative `amount` values represent credits or adjustments.

## Collect repayments

### Create a one-off repayment

Create a repayment using the payment method and customer set up during consumer onboarding:

```curl
curl https://api.stripe.com/v1/issuing/credit_repayments \
  -u "sk_test_...:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "instructed_by[type]=credit_repayments_api" \
  -d "instructed_by[credit_repayments_api][payment_method]={{PAYMENT_METHOD_ID}}" \
  -d "amount[value]=1000" \
  -d "amount[currency]=usd" \
  -d "credit_statement_descriptor=Payment received"
```

Stripe sends webhooks as the repayment progresses: `issuing.credit_repayment.processing` when the ACH debit is initiated, `issuing.credit_repayment.succeeded` when it settles, and `issuing.credit_repayment.failed` if it fails (for example, insufficient funds or a bank return).

If a repayment fails, retrieve failure details from the Payment Records API using the `payment_record` ID from the repayment object:

```curl
curl https://api.stripe.com/v1/payment_records/{{PAYMENTRECORD_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-06-24.preview; payment_records_beta=v2;"
```

### Schedule recurring repayments

Create a repayment schedule to automatically initiate recurring ACH repayments. This example configures a fixed amount repayment on the 15th of each month:

```curl
curl https://api.stripe.com/v1/issuing/credit_repayment_schedules \
  -u "sk_test_...:" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method={{PAYMENT_METHOD_ID}}" \
  -d "amount_details[type]=fixed_amount" \
  -d "amount_details[fixed_amount][amount][value]=1000" \
  -d "amount_details[fixed_amount][amount][currency]=usd" \
  -d "frequency[type]=monthly" \
  -d "frequency[monthly][day_of_month]=15" \
  -d "credit_statement_descriptor=Payment received"
```

Supported `amount_details` types include `fixed_amount`, `current_balance`, `remaining_minimum_balance`, and `remaining_statement_balance`. The `next_repayment.scheduled_on` field on the schedule shows when the next repayment will be initiated.

Scheduled repayments send the same webhooks as one-off repayments. The `Credit Repayment` object includes a `credit_repayment_schedule` field linking back to the schedule.

## Handle disputes

Use the [Create Dispute API](https://docs.stripe.com/api/issuing/disputes/create.md) to submit a dispute raised by a cardholder to the card network. See [Issuing disputes](https://docs.stripe.com/issuing/purchases/disputes.md) for the full dispute lifecycle and webhook events.