# マーケットプレイスの構築

アカウント v1 を使用して連結アカウントを作成し、顧客から支払いを回収します。そしてマーケットプレイスの販売者または代行業者に支払います。

> #### Accounts v2 API のシステム連携
> 
> このガイドは、Accounts v1 API を使用する既存の Connect プラットフォームにのみ該当します。新規の Connect ユーザー、または Accounts v2 API をご利用の場合は、[v2 Marketplace guide](https://docs.stripe.com/connect/marketplace.md) をご覧ください。

# Web

> This is a Web for when platform is web. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=web.

このガイドでは、決済を受け付け、売上をサービスプロバイダーや売り手の銀行口座に移動する方法を説明します。デモンストレーションでは、住宅所有者と賃貸物件を探す人を結びつける賃貸住宅のマーケットプレイスを構築します。また、テナント (顧客) から支払いを受け付け、住宅所有者 (プラットフォームのユーザー) に支払う方法についても説明します。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバー側]

Stripe の公式ライブラリをインストールし、アプリケーションから API にアクセスします。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## 連結アカウントを作成する

#### Accounts v2

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/v2/core/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

#### Accounts v1

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

### 情報を事前入力して連結アカウントを作成する

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 支払い方法を有効にする

[支払い方法の設定](https://dashboard.stripe.com/settings/payment_methods)を表示し、サポートする支払い方法を有効にします。カード支払い、Google Pay、Apple Pay はデフォルトで有効化されていますが、支払い方法は必要に応じて有効または無効に設定できます。

決済フォームを表示する前に、Stripe は通貨、決済手段の制約、その他のパラメーターを評価し、対応可能な決済手段のリストを決定します。購入完了率の向上につながり、使用通貨と顧客の所在地に最も適した決済手段が、優先的に表示されます。優先度の低い決済手段は、オーバーフローメニューに隠れた状態になります。

## 決済を受け付ける

[Stripe Checkout](https://stripe.com/payments/checkout) を使用して決済を受け付けます。Checkout は複数の支払い方法に対応し、顧客に最適な方法を自動的に表示します。Stripe がオンラインで提供するページを使用して Checkout で決済を受け付けるか、事前構築済みのオンライン支払いフォームを自社のウェブサイトに直接追加することができます。また、(Payment Element を使用して) カスタムフローを構築して、1 回のフロンドエンド実装で複数の支払い方法を受け付けることも可能です。

#### Stripe がホストするページ

### Checkout セッションを作成する (クライアントおよびサーバー)

Checkout セッションは、ラインアイテム、注文金額と通貨、および受け付け可能な支払い方法など、Stripe のオンライン決済ページで顧客に表示する内容を制御します。

サーバー側のエンドポイントを呼び出して Checkout セッションを作成する購入ボタンをウェブサイトに追加します。

```html
<html>
  <head>
    <title>Checkout</title>
  </head>
  <body>
    <form action="/create-checkout-session" method="POST">
      <button type="submit">Checkout</button>
    </form>
  </body>
</html>
```

サーバー側で、Stripe の API に以下の呼び出しを行います。Checkout セッションを作成したら、レスポンスで返された [URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) に顧客をリダイレクトします。

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=1" \
  -d "payment_intent_data[application_fee_amount]=123" \
  -d "payment_intent_data[transfer_data][destination]={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "success_url=https://example.com/success"
```

- `line_items`: この引数は、顧客が購入しようとしているアイテムを表します。このアイテムは Stripe がオンラインで提供するユーザーインターフェイスに表示されます。
- `success_url`: この引数は、支払いを完了したユーザーのリダイレクト先を示します。
- `payment_intent_data[application_fee_amount]`: この引数は、プラットフォームが取引で受け取る予定の金額を指定します。支払いがキャプチャーされると、プラットフォームから、`transfer_data[destination]` で指定された連結アカウントに支払い金額の全額が即時送金されます。その後 `application_fee_amount` がプラットフォームに返金され、プラットフォームの金額から Stripe 手数料が差し引かれます。
- `payment_intent_data[transfer_data][destination]`: この引数は、支払いが[デスティネーション支払い](https://docs.stripe.com/connect/destination-charges.md)であることを示します。デスティネーション支払いでは、支払いがプラットフォームで処理され、売上が即時かつ自動的に連結アカウントの保留中の残高に送金されます。賃貸住宅の例では、顧客がプラットフォームを使用して支払い、住宅所有者がプラットフォームで支払いを受ける機能を構築します。
![](https://b.stripecdn.com/docs-statics-srv/assets/application_fee_amount.837aa2339469b3c1a4319672971c1367.svg)

Checkout では、デスティネーション支払いにプラットフォームアカウントのブランド設定を使用します。詳細については、[ブランディングをカスタマイズする](https://docs.stripe.com/connect/destination-charges.md?platform=web&ui=stripe-hosted#branding)をご覧ください。

このセッションは、デスティネーション支払いを作成します。送金のタイミングを管理したり、1 回の支払いの売上を複数の当事者に送金したりする必要がある場合は、代わりに[支払いと送金別方式](https://docs.stripe.com/connect/separate-charges-and-transfers.md)を使用してください。

### 支払い後のイベントを処理する (サーバー側)

支払いが完了すると Stripe は [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed) イベントを送信します。[Webhook を使用してこのイベントを受信](https://docs.stripe.com/webhooks/quickstart.md)し、顧客への注文確認メールの送信、データベースへの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアント側では、コールバックの実行前に顧客がブラウザーのウィンドウを閉じたり、アプリケーションを終了したりする可能性があります。また、一部の支払い方法では支払いの確定までに 2 ～ 14 日かかることがあります。実装で非同期イベントをリッスンするように設定すると、1 つの実装で複数の[支払い方法](https://stripe.com/payments/payment-methods-guide)に対応できるようになります。

Checkout で支払いを回収するときは、`checkout.session.completed` イベントの処理に加えて、以下の 2 つのイベントも処理することをお勧めします。

| イベント                                                                                                                                         | 説明                                    | 次のステップ                       |
| -------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------- | ---------------------------- |
| [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed)                             | 顧客が Checkout フォームを送信して、支払いを正常に承認しました。 | 支払いの成功または失敗の結果を待ちます。         |
| [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) | 顧客の支払いが成功しました。                        | 購入された商品やサービスのフルフィルメントを行います。  |
| [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed)       | 何らかの理由により支払いが拒否されたか、失敗しました。           | 顧客にメールで連絡して、新たに注文するように依頼します。 |

これらのイベントのすべてに、[Checkout Session (Checkout セッション)](https://docs.stripe.com/api/checkout/sessions.md) オブジェクトが含まれています。支払いが成功すると、基となる *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) のステータスが `processing` から `succeeded` に変わります。

#### オンラインフォーム

### Checkout セッションを作成する (サーバー側)

Checkout セッションは、ラインアイテム、注文金額と通貨、および受け付け可能な支払い方法など、オンライン支払いフォームで顧客に表示する内容を制御します。

自身のサーバーで、Stripe の API に対して次の呼び出しを実行します。

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=1" \
  -d "payment_intent_data[application_fee_amount]=123" \
  -d "payment_intent_data[transfer_data][destination]={{CONNECTEDACCOUNT_ID}}" \
  -d ui_mode=embedded_page \
  --data-urlencode "return_url=https://example.com/checkout/return?session_id={CHECKOUT_SESSION_ID}"
```

- `line_items`: 顧客が購入しようとしているアイテムを表します。このアイテムは Stripe がオンラインで提供するユーザーインターフェイスに表示されます。
- `return_url`: この引数は、支払いを完了したユーザーのリダイレクト先を示します。
- `payment_intent_data[application_fee_amount]`: この引数は、プラットフォームが取引で受け取る予定の金額を指定します。支払いがキャプチャーされると、プラットフォームから、`transfer_data[destination]` で指定された連結アカウントに支払い金額の全額が即時送金されます。その後 `application_fee_amount` がプラットフォームに返金され、プラットフォームの金額から Stripe 手数料が差し引かれます。
- `payment_intent_data[transfer_data][destination]`: 支払いが[デスティネーション支払い](https://docs.stripe.com/connect/destination-charges.md)であることを示します。デスティネーション支払いでは、支払いがプラットフォームで処理され、売上が即時かつ自動的に連結アカウントの保留中の残高に送金されます。賃貸住宅の例では、顧客がプラットフォームを使用して支払う場合、住宅所有者はプラットフォームから支払いを受け取ります。

### Checkout をマウントする (クライアント側)

#### HTML + JS

Checkout は [Stripe.js](https://docs.stripe.com/js.md) の一部として利用できます。HTML ファイルのヘッダーに Stripe.js スクリプトを追加してページに含めます。次に、マウンティングに使用する空の DOM ノード (コンテナー) を作成します。

```html
<head>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
<body>
  <div id="checkout">
    <!-- Checkout will insert the payment form here -->
  </div>
</body>
```

公開可能な API キーで Stripe.js を初期化します。

Checkout セッションの作成、および client secret の取得をサーバーにリクエストする、非同期の `fetchClientSecret` 関数を作成します。 Checkout インスタンスを作成する際に、この関数を `options` に渡します。

```javascript
// Initialize Stripe.js
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');

initialize();

// Fetch Checkout Session and retrieve the client secret
async function initialize() {
  const fetchClientSecret = async () => {
    const response = await fetch("/create-checkout-session", {
      method: "POST",
    });
    const { clientSecret } = await response.json();
    return clientSecret;
  };

  // Initialize Checkout
  const checkout = await stripe.createEmbeddedCheckoutPage({
    fetchClientSecret,
  });

  // Mount Checkout
  checkout.mount('#checkout');
}
```

#### React

Connect.js と React Connect.js のライブラリを [npm のパブリックレジストリー](https://www.npmjs.com/package/@stripe/react-connect-js)からインストールします。

```bash
npm install --save @stripe/connect-js @stripe/react-connect-js
```

埋め込みの Checkout コンポーネントを使用するには、`EmbeddedCheckoutProvider` を作成します。公開可能 API キーを使用して `loadStripe` を呼び出し、返された `Promise` をプロバイダーに渡します。

Checkout セッションの作成、および client secret の取得をサーバーにリクエストする、非同期の `fetchClientSecret` 関数を作成します。この関数をプロバイダーで受け入れられる `options` プロパティに渡します。

```jsx
import * as React from 'react';
import {loadStripe} from '@stripe/stripe-js';
import {
  EmbeddedCheckoutProvider,
  EmbeddedCheckout
} from '@stripe/react-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('pk_test_123');

const App = ({fetchClientSecret}) => {
  const options = {fetchClientSecret};

  return (
    <EmbeddedCheckoutProvider
      stripe={stripePromise}
      options={options}
    >
      <EmbeddedCheckout />
    </EmbeddedCheckoutProvider>
  )
}
```

Checkout は、HTTPS 接続を介して支払い情報を Stripe に安全に送信する iframe に表示されます。一部の支払い方法では、支払いを確定するために別のページにリダイレクトする必要があるため、Checkout を別の iframe 内に配置しないでください。
![](https://b.stripecdn.com/docs-statics-srv/assets/application_fee_amount.837aa2339469b3c1a4319672971c1367.svg)

Checkout では、デスティネーション支払いにプラットフォームアカウントのブランド設定を使用します。詳細については、[ブランディングをカスタマイズする](https://docs.stripe.com/connect/destination-charges.md?platform=web&ui=stripe-hosted#branding)をご覧ください。

このセッションは、デスティネーション支払いを作成します。送金のタイミングを管理したり、1 回の支払いの売上を複数の当事者に送金したりする必要がある場合は、代わりに[支払いと送金別方式](https://docs.stripe.com/connect/separate-charges-and-transfers.md)を使用してください。

### 支払い後のイベントを処理する (サーバー側)

支払いが完了すると Stripe は [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed) イベントを送信します。[Webhook を使用してこのイベントを受信](https://docs.stripe.com/webhooks/quickstart.md)し、顧客への注文確認メールの送信、データベースへの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアント側では、コールバックの実行前に顧客がブラウザーのウィンドウを閉じたり、アプリケーションを終了したりする可能性があります。また、一部の支払い方法では支払いの確定までに 2 ～ 14 日かかることがあります。実装で非同期イベントをリッスンするように設定すると、1 つの実装で複数の[支払い方法](https://stripe.com/payments/payment-methods-guide)に対応できるようになります。

Checkout で支払いを回収するときは、`checkout.session.completed` イベントの処理に加えて、以下の 2 つのイベントも処理することをお勧めします。

| イベント                                                                                                                                         | 説明                                    | 次のステップ                       |
| -------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------- | ---------------------------- |
| [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed)                             | 顧客が Checkout フォームを送信して、支払いを正常に承認しました。 | 支払いの成功または失敗の結果を待ちます。         |
| [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) | 顧客の支払いが成功しました。                        | 購入された商品やサービスのフルフィルメントを行います。  |
| [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed)       | 何らかの理由により支払いが拒否されたか、失敗しました。           | 顧客にメールで連絡して、新たに注文するように依頼します。 |

これらのイベントのすべてに、[Checkout Session (Checkout セッション)](https://docs.stripe.com/api/checkout/sessions.md) オブジェクトが含まれています。支払いが成功すると、基となる *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) のステータスが `processing` から `succeeded` に変わります。

#### カスタムフロー

### PaymentIntent を作成する (サーバー側)

Stripe は [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md) オブジェクトを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して請求の実施と支払い状態の変化を追跡します。

> 最初に PaymentIntent を作成せずに Payment Element をレンダリングする場合は、[インテントを作成する前に支払いの詳細を収集する](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment)をご覧ください。
![決済フロー全体の概要図](https://b.stripecdn.com/docs-statics-srv/assets/accept-a-payment-payment-element.5cf6795a02f864923f9953611493d735.svg)

購入プロセスで顧客に表示される支払い方法は、PaymentIntent にも含まれています。Stripe によってダッシュボードの設定から支払い方法を自動的に取得することも、手動でリスト化することもできます。

決済手段の提供にコードベースのオプションを必要とする場合を除き、自動のオプションをお勧めします。これは、Stripe で通貨、決済手段の制約、その他のパラメーターを評価し、対応可能な決済手段のリストが決定されるためです。この場合、コンバージョン率上昇につながり、使用通貨と顧客の所在地に最も適した決済手段が優先的に表示されます。優先度の低い決済手段は、オーバーフローメニューに隠れた状態となります。

#### ダッシュボードで支払い方法を管理する

サーバーで、金額と通貨を有効化して PaymentIntent を作成します。最新バージョンの API では、機能がデフォルトで有効になっているため、`automatic_payment_methods` パラメーターの指定が任意になりました。支払い方法は[ダッシュボード](https://dashboard.stripe.com/settings/payment_methods)で管理できます。Stripe は取引額、通貨、決済フローなどの要素に基づいて、適切な支払い方法が返されるように処理します。これにより、ダッシュボードで設定した支払い方法をサポートするための PaymentIntent が作成されます。支払い金額は、クライアント側ではなく、常に信頼できる環境であるサーバー側で指定してください。これにより、悪意のある顧客が金額を恣意的に選択できないようにします。

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=eur \
  -d "automatic_payment_methods[enabled]=true" \
  -d application_fee_amount=123 \
  -d "transfer_data[destination]={{CONNECTEDACCOUNT_ID}}"
```

#### 支払い方法を手動で一覧表示する

サーバーで金額、通貨、支払い方法のタイプのリストを指定して PaymentIntent を作成します。支払い金額は、クライアント側ではなく、常に信頼できる環境のサーバー側で指定してください。これにより、悪意のある顧客が恣意的な金額を選択できないようにします。

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  -d amount=1099 \
  -d currency=eur \
  -d "payment_method_types[]=bancontact" \
  -d "payment_method_types[]=card" \
  -d "payment_method_types[]=eps" \
  -d "payment_method_types[]=ideal" \
  -d "payment_method_types[]=p24" \
  -d "payment_method_types[]=sepa_debit" \
  -d "payment_method_types[]=sofort" \
  -d application_fee_amount=123
```

受け付ける決済手段に応じて通貨を選択します。一部の決済手段は、複数の通貨と国に対応しています。このガイドでは、Bancontact、クレジットカード、EPS、iDEAL、Przelewy24、SEPA ダイレクトデビット、Sofort を使用します。

> 各支払い方法は PaymentIntent で渡された通貨に対応している必要があり、ビジネスは、各支払い方法を使用できる国のいずれかに所在する必要があります。対応状況について、詳細は[支払い方法の導入オプション](https://docs.stripe.com/payments/payment-methods/integration-options.md)をご覧ください。

### client secret を取得する

PaymentIntent には、*client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) が含まれています。これは、支払いプロセスを安全に完了するためにクライアント側で使用されます。client secret をクライアント側に渡す際は、いくつかの方法を使用できます。

#### 1 ページのアプリケーション

ブラウザーの `fetch` 関数を使用して、サーバーのエンドポイントから client secret を取得します。この方法は、クライアント側が 1 ページのアプリケーションで、特に React などの最新のフロントエンドフレームワークで構築されている場合に最適です。client secret を処理するサーバーのエンドポイントを作成します。

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

その後、クライアント側で JavaScript を使用して client secret を取得します。

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### サーバ側のレンダリング

サーバーからクライアントに client secret を渡します。この方法は、アプリケーションがブラウザーへの送信前に静的なコンテンツをサーバーで生成する場合に最適です。

決済フォームに [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) を追加します。サーバー側のコードで、PaymentIntent から client secret を取得します。

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <div id="payment-element">
    <!-- placeholder for Elements -->
  </div>
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

### 支払い情報を収集する (クライアント側)

[Payment Element](https://docs.stripe.com/payments/payment-element.md) を使用してクライアント側で支払い詳細を収集します。Payment Element は事前構築された UI コンポーネントであり、さまざまな決済手段の詳細の収集をシンプルにします。

Payment Element には、HTTPS 接続を介して支払い情報を Stripe に安全に送信する iframe が含まれています。一部の支払い方法では、支払いを確定するために別のページにリダイレクトする必要があるため、Payment Element を別の iframe 内に配置しないでください。

iframe を使用して Apple Pay または Google Pay を受け付けたい場合は、iframe の [allow](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) 属性を `"payment *"` と等しく設定する必要があります。

構築済みのシステムを機能させるには、決済ページのアドレスの先頭を `http://` ではなく `https://` にする必要があります。HTTPS を使用しなくてもシステムをテストできますが、本番環境で決済を受け付ける準備が整ったら、必ず、HTTPS を[有効](https://docs.stripe.com/security/guide.md#tls)にしてください。

#### HTML + JS

### Stripe.js を設定する

Payment Element は Stripe.js の機能として自動的に使用できるようになります。決済ページに Stripe.js スクリプトを含めるには、HTML ファイルの `head` にスクリプトを追加します。常に js.stripe.com から Stripe.js を直接読み込むことにより、PCI 準拠が維持されます。スクリプトをバンドルに含めたり、そのコピーを自身でホストしたりしないでください。

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

決済ページで以下の JavaScript を使用して、Stripe のインスタンスを作成します。

```javascript
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

### Payment Element を支払いページに追加する

Payment Element を決済ページに配置する場所が必要です。決済フォームで、一意の ID を持つ空の DOM ノード (コンテナー) を作成します。

```html
<form id="payment-form">
  <div id="payment-element">
    <!-- Elements will create form elements here -->
  </div>
  <button id="submit">Submit</button>
  <div id="error-message">
    <!-- Display error message to your customers here -->
  </div>
</form>
```

前のフォームが読み込まれたら、Payment Element のインスタンスを作成して、それをコンテナーの DOM ノードにマウントします。[Elements](https://docs.stripe.com/js/elements_object/create) インスタンスを作成する際に、前のステップからの [client secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) を `options` に渡します。

client secret は支払いを完了できるため、慎重に取り扱う必要があります。記録したり、URL に埋め込んだり、当該の顧客以外に漏洩することがないようにしてください。

```javascript
const options = {
  clientSecret: '{{CLIENT_SECRET}}',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout form, passing the client secret obtained in a previous stepconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');

```

#### React

### Stripe.js を設定する

次の npm パブリックレジストリーから [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) と [Stripe.js ローダー](https://www.npmjs.com/package/@stripe/stripe-js)をインストールします。

```bash
npm install --save @stripe/react-stripe-js @stripe/stripe-js
```

### Elements プロバイダーを支払いページに追加して設定する

Payment Element コンポーネントを使用するには、決済ページコンポーネントを [Elements プロバイダー](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider)でラップします。公開キーを使用して `loadStripe` を呼び出し、返された `Promise` を `Elements` プロバイダーに渡します。加えて、前のステップの [client secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) を `options` にして `Elements` プロバイダーに渡します。

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {
    // passing the client secret obtained in step 3
    clientSecret: '{{CLIENT_SECRET}}',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

### Payment Element コンポーネントを追加する

`PaymentElement` コンポーネントを使用して、フォームを構築します。

```jsx
import React from 'react';
import {PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  return (
    <form><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

Stripe Elements は、ドロップイン UI コンポーネントのコレクションです。フォームをさらにカスタマイズしたり、その他の顧客情報を収集したりする場合は、[Elements のドキュメント](https://docs.stripe.com/payments/elements.md)をご覧ください。

Payment Element によって動的なフォームが表示され、顧客はここで支払い方法を選択できます。支払い方法ごとに、フォームでは、必要な支払いの詳細のすべてを入力するように顧客に自動的に求めます。

### デザインをカスタマイズする

`Elements` プロバイダーを作成する際に、[Appearance (デザイン) オブジェクト](https://docs.stripe.com/js/elements_object/create#stripe_elements-options-appearance)を `options` に渡すことで、サイトのデザインに合わせて Payment Element をカスタマイズできます。

### 住所を収集

デフォルトでは、Payment Element は必要な請求住所の詳細のみを収集します。[税金の計算](https://docs.stripe.com/api/tax/calculations/create.md)、配送先情報を入力するなどの一部の動作では、顧客の完全な住所が必要です。次のように対応できます。

- [Address Element](https://docs.stripe.com/elements/address-element.md) を使用して、オートコンプリートとローカリゼーションの機能を利用して、顧客の完全な住所を収集します。これにより、最も正確な税金計算が可能になります。
- 独自のカスタムフォームを使用して住所の詳細を収集する。

### Apple Pay マーチャントトークンをリクエストする

連携機能を [Apple Pay 決済を受け付ける](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout)ように設定している場合は、加盟店が開始する取引 (MIT) を有効にするために、Apple Pay インターフェイスがマーチャントトークンを返すように設定することをお勧めします。Payment Element で[関連するマーチャントトークンのタイプをリクエスト](https://docs.stripe.com/apple-pay/merchant-tokens.md?pay-element=web-pe)してください。

### Stripe に支払いを送信する (クライアント側)

Payment Element からの詳細を指定して [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) を使用し、支払いを完了します。ユーザーが支払いを完了した後に Stripe がユーザーをリダイレクトする場所を指定するには、この関数に [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) を指定します。ユーザーはまず、銀行のオーソリページなどの中間サイトにリダイレクトされ、その後 `return_url` にリダイレクトされます。カード支払いでは、支払いが正常に完了するとすぐに `return_url` にリダイレクトします。

カード決済で支払いの完了後にリダイレクトを行わない場合は、[redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) に `if_required` を設定できます。これで、リダイレクトベースの決済手段で購入する顧客のみがリダイレクトされます。

#### HTML + JS

```javascript
const form = document.getElementById('payment-form');

form.addEventListener('submit', async (event) => {
  event.preventDefault();
const {error} = await stripe.confirmPayment({
    //`Elements` instance that was used to create the Payment Element
    elements,
    confirmParams: {
      return_url: 'https://example.com/order/123/complete',
    },
  });

  if (error) {
    // This point will only be reached if there is an immediate error when
    // confirming the payment. Show error to your customer (for example, payment
    // details incomplete)
    const messageContainer = document.querySelector('#error-message');
    messageContainer.textContent = error.message;
  } else {
    // Your customer will be redirected to your `return_url`. For some payment
    // methods like iDEAL, your customer will be redirected to an intermediate
    // site first to authorize the payment, then redirected to the `return_url`.
  }
});
```

#### React

支払いフォームコンポーネントから [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) を呼び出すには、[useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook) フックと [useElements](https://docs.stripe.com/sdks/stripejs-react.md#useelements-hook) フックを使用します。

フックではなく従来のクラスコンポーネントを使用する場合は、代わりに [ElementsConsumer](https://docs.stripe.com/sdks/stripejs-react.md#elements-consumer) を使用します。

```jsx
import React, {useState} from 'react';
import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  const stripe = useStripe();
  const elements = useElements();

  const [errorMessage, setErrorMessage] = useState(null);

  const handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    if (!stripe || !elements) {
      // Stripe.js hasn't yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }
const {error} = await stripe.confirmPayment({
      //`Elements` instance that was used to create the Payment Element
      elements,
      confirmParams: {
        return_url: 'https://example.com/order/123/complete',
      },
    });


    if (error) {
      // This point will only be reached if there is an immediate error when
      // confirming the payment. Show error to your customer (for example, payment
      // details incomplete)
      setErrorMessage(error.message);
    } else {
      // Your customer will be redirected to your `return_url`. For some payment
      // methods like iDEAL, your customer will be redirected to an intermediate
      // site first to authorize the payment, then redirected to the `return_url`.
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button disabled={!stripe}>Submit</button>
      {/* Show error message to your customers */}
      {errorMessage && <div>{errorMessage}</div>}
    </form>
  );
};

export default CheckoutForm;
```

`return_url` が、Web サイト上の支払いステータスを表示するページと対応していることを確認します。Stripe が顧客を `return_url` にリダイレクトするときは、以下の URL クエリーパラメーターが指定されます。

| パラメーター                         | 説明                                                                                                                                  |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent`               | `PaymentIntent` の一意の識別子。                                                                                                            |
| `payment_intent_client_secret` | `PaymentIntent` オブジェクトの [client secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret)。 |

> 顧客のブラウザーセッションを追跡するツールを利用している場合、リファラー除外リストに `stripe.com` ドメインの追加が必要になる場合があります。リダイレクトを行うと、一部のツールでは新しいセッションが作成され、セッション全体の追跡ができなくなります。

クエリパラメーターのいずれか 1 つを使用して PaymentIntent を取得します。[PaymentIntent のステータス](https://docs.stripe.com/payments/paymentintents/lifecycle.md)を調べて、顧客に表示する内容を決定します。また、`return_url` を指定するときにカスタムのクエリパラメーターを追加することもできます。このパラメーターはリダイレクトプロセスの間維持されます。

#### HTML + JS

```javascript

// Initialize Stripe.js using your publishable key
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');

// Retrieve the "payment_intent_client_secret" query parameter appended to
// your return_url by Stripe.js
const clientSecret = new URLSearchParams(window.location.search).get(
  'payment_intent_client_secret'
);

// Retrieve the PaymentIntent
stripe.retrievePaymentIntent(clientSecret).then(({paymentIntent}) => {
  const message = document.querySelector('#message')

  // Inspect the PaymentIntent `status` to indicate the status of the payment
  // to your customer.
  //
  // Some payment methods will [immediately succeed or fail][0] upon
  // confirmation, while others will first enter a `processing` state.
  //
  // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification
  switch (paymentIntent.status) {
    case 'succeeded':
      message.innerText = 'Success! Payment received.';
      break;

    case 'processing':
      message.innerText = "Payment processing. We'll update you when payment is received.";
      break;

    case 'requires_payment_method':
      message.innerText = 'Payment failed. Please try another payment method.';
      // Redirect your user back to your payment page to attempt collecting
      // payment again
      break;

    default:
      message.innerText = 'Something went wrong.';
      break;
  }
});
```

#### React

```jsx
import React, {useState, useEffect} from 'react';
import {useStripe} from '@stripe/react-stripe-js';

const PaymentStatus = () => {
  const stripe = useStripe();
  const [message, setMessage] = useState(null);

  useEffect(() => {
    if (!stripe) {
      return;
    }

    // Retrieve the "payment_intent_client_secret" query parameter appended to
    // your return_url by Stripe.js
    const clientSecret = new URLSearchParams(window.location.search).get(
      'payment_intent_client_secret'
    );

    // Retrieve the PaymentIntent
    stripe
      .retrievePaymentIntent(clientSecret)
      .then(({paymentIntent}) => {
        // Inspect the PaymentIntent `status` to indicate the status of the payment
        // to your customer.
        //
        // Some payment methods will [immediately succeed or fail][0] upon
        // confirmation, while others will first enter a `processing` state.
        //
        // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification
        switch (paymentIntent.status) {
          case 'succeeded':
            setMessage('Success! Payment received.');
            break;

          case 'processing':
            setMessage("Payment processing. We'll update you when payment is received.");
            break;

          case 'requires_payment_method':
            // Redirect your user back to your payment page to attempt collecting
            // payment again
            setMessage('Payment failed. Please try another payment method.');
            break;

          default:
            setMessage('Something went wrong.');
            break;
        }
      });
  }, [stripe]);


  return message;
};

export default PaymentStatus;
```

### 支払い後のイベントを処理する (サーバー側)

支払いが完了すると、Stripe は [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) イベントを送信します。[ダッシュボードの Webhook ツール](https://dashboard.stripe.com/webhooks)を使用するか [Webhook のガイド](https://docs.stripe.com/webhooks/quickstart.md)に従ってこれらのイベントを受信し、顧客への注文確認メールの送信、データベースでの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアントでは、コールバックが実行される前に顧客がブラウザーのウィンドウを閉じたり、アプリを終了する場合、また悪意を持つクライアントがレスポンスを不正操作する場合もあります。非同期型のイベントをリッスンするよう組み込みを設定すると、単一の組み込みで[複数の異なるタイプの支払い方法](https://stripe.com/payments/payment-methods-guide)を受け付けることができます。

Payment Element を使用して支払いを回収する場合は、`payment_intent.succeeded` イベントのほかにこれらのイベントを処理することをお勧めします。

| イベント                                                                                                                            | 説明                                                                                                                                                                       | アクション                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded)           | 顧客が正常に支払いを完了したときに送信されます。                                                                                                                                                 | 顧客に注文の確定を送信し、顧客の注文の*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を実行します。 |
| [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing)         | 顧客が正常に支払いを開始したが、支払いがまだ完了していない場合に送信されます。このイベントは、多くの場合、顧客が口座引き落としを開始するときに送信されます。その後、`payment_intent.succeeded` イベント、また、失敗の場合は `payment_intent.payment_failed` イベントが送信されます。 | 顧客に注文確認メールを送信し、支払いが保留中であることを示します。デジタル商品では、支払いの完了を待たずに注文のフルフィルメントを行うことが必要になる場合があります。                                                                                |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | 顧客が支払いを試みたが、支払いに失敗する場合に送信されます。                                                                                                                                           | 支払いが `processing` から `payment_failed` に変わった場合は、顧客に再度支払いを試すように促します。                                                                                                 |

## テスト

[アカウントを作成](https://docs.stripe.com/connect/testing.md#creating-accounts)し、[OAuth を使用](https://docs.stripe.com/connect/testing.md#using-oauth)して、アカウント作成フローをテストします。

#### カード

| カード番号               | シナリオ                                                                                                                                                                                                                                                                 | テスト方法                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| 4242424242424242    | カード支払いは成功し、認証は必要とされません。                                                                                                                                                                                                                                              | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000002500003155    | カード支払いには*認証* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase)が必要です。 | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000000000009995    | カードは、`insufficient_funds` などの拒否コードで拒否されます。                                                                                                                                                                                                                           | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 6205500000000000004 | UnionPay カードは、13 ～ 19 桁の可変長です。                                                                                                                                                                                                                                       | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |

#### ウォレット

| 決済手段   | シナリオ                                                                                                            | テスト方法                                                                                                     |
| ------ | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| Alipay | 顧客はリダイレクトベースの[即時通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法で支払いに成功します。 | リダイレクトベースの任意の支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Complete test payment (テスト支払い完了)** をクリックします。 |

#### 銀行へのリダイレクト

| 決済手段                            | シナリオ                                                                                                             | テスト方法                                                                                                                               |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| BECS ダイレクトデビット                  | 顧客が BECS ダイレクトデビットによる支払いに成功しました。                                                                                 | アカウント番号 `900123456` と BSB `000000` を使用して、フォームに入力します。確定された PaymentIntent のステータスは、まず `processing` に移行し、3 分後に `succeeded` ステータスに移行します。 |
| BECS ダイレクトデビット                  | 顧客の支払いが `account_closed` エラーコードで失敗します。                                                                           | アカウント番号 `111111113`と BSB `000000`を使用して、フォームに入力します。                                                                                  |
| Bancontact、EPS、iDEAL、Przelewy24 | 顧客は、リダイレクトベースの即時通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | リダイレクトベースの任意の支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払い失敗)** をクリックします。                               |
| Pay by Bank                     | 顧客はリダイレクトベースの、[遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法で支払いに成功します。 | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Complete test payment (テスト支払い完了)** をクリックします。                                        |
| Pay by Bank                     | 顧客は、リダイレクトベースの遅延通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払いを失敗させる)** をクリックします。                                        |
| BLIK                            | BLIK による支払いはさまざまな理由で失敗します。即時の失敗 (コードの有効期限切れや無効など)、遅延型のエラー (銀行による拒否など)、またはタイムアウト (顧客が時間内に応答しなかったなど) などがあります。      | メールパターンを使用して[さまざまな失敗をシミュレーションします。](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures)                     |

#### 口座引き落とし

| 決済手段           | シナリオ                                                                         | テスト方法                                                                                                                   |
| -------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| SEPA ダイレクトデビット | 顧客が SEPA ダイレクトデビットによる支払いに成功しました。                                             | 口座番号 `AT321904300235473204` を使用して、フォームに入力します。確定された PaymentIntent のステータスはまず、processing に移行し、3 分後に succeeded ステータスに移行します。 |
| SEPA ダイレクトデビット | 顧客の Payment Intent のステータスが、`processing` から `requires_payment_method` に移行します。 | 口座番号 `AT861904300235473202` を使用して、フォームに入力します。                                                                           |

#### 店舗支払い

| 決済手段        | シナリオ                                  | テスト方法                                                         |
| ----------- | ------------------------------------- | ------------------------------------------------------------- |
| Boleto、OXXO | 顧客が Boleto または OXXO で取引の詳細を使用して支払います。 | 支払い方法として Boleto または OXXO を選択し、支払いを送信します。ダイアログが表示されたら、それを閉じます。 |

実装内容をテストするためのその他の情報については、[テスト](https://docs.stripe.com/testing.md)をご覧ください。


# 決済画面

> This is a 決済画面 for when platform is ios and mobile-ui is payment-element. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=ios&mobile-ui=payment-element.
![](https://b.stripecdn.com/docs-statics-srv/assets/ios-overview.9e0d68d009dc005f73a6f5df69e00458.png)

[PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html) クラスを使用して、Stripe の構築済み決済 UI を iOS アプリの決済フローに組み込みます。[GitHub](https://github.com/stripe/stripe-ios/tree/master/Example/PaymentSheet%20Example) のサンプル実装をご覧ください。

このガイドは、決済を受け付け、売上を売り手やサービスプロバイダーの銀行口座に移動する方法をデモンストレーションします。デモンストレーションでは、住宅所有者とレンタル物件を探す人を結びつける住宅賃貸のマーケットプレイスを構築します。このガイドで扱われる概念を他のアプリケーションにも適用することができます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバ側] [クライアント側]

まず、Stripe アカウントが必要です。[今すぐ登録](https://dashboard.stripe.com/register)してください。

### サーバ側

この組み込みには、サーバ上に Stripe API と通信するエンドポイントが必要です。サーバから Stripe API にアクセスするには、Stripe の公式ライブラリを使用します。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### クライアント側

[Stripe iOS SDK](https://github.com/stripe/stripe-ios) はオープンソースです。[詳細なドキュメントが提供されており](https://stripe.dev/stripe-ios/index.html)、iOS 13 以降をサポートするアプリと互換性があります。

#### Swift Package Manager

SDK をインストールするには、以下のステップに従います。

1. Xcode で、**File (ファイル)** > **Add Package Dependencies… (パッケージ依存関係を追加)** を選択し、リポジトリー URL として `https://github.com/stripe/stripe-ios-spm` を入力します。
1. [リリースページ](https://github.com/stripe/stripe-ios/releases)から最新のバージョン番号を選択します。
1. **StripePaymentsUI** 製品を[アプリのターゲット](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app)に追加します。

#### CocoaPods

1. まだインストールしていない場合は、[CocoaPods](https://guides.cocoapods.org/using/getting-started.html) の最新バージョンをインストールします。
1. 既存の [Podfile](https://guides.cocoapods.org/syntax/podfile.html) がない場合は、以下のコマンドを実行して作成します。
   ```bash
   pod init
   ```
1. この行を `Podfile` に追加します。
   ```podfile
   pod 'StripePaymentsUI'
   ```
1. 以下のコマンドを実行します。
   ```bash
   pod install
   ```
1. これ以降は、Xcode でプロジェクトを開く際に、`.xcodeproj` ファイルではなく、必ず `.xcworkspace` ファイルを使用するということを忘れないでください。
1. 今後、SDK の最新バージョンに更新するには、以下を実行します。
   ```bash
   pod update StripePaymentsUI
   ```

#### Carthage

1. まだインストールしていない場合は、[Carthage](https://github.com/Carthage/Carthage#installing-carthage) の最新バージョンをインストールします。
1. この行を `Cartfile` に追加します。
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. [Carthage のインストール手順](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos)に従います。必ず、[こちら](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking)にリストされている必要なフレームワークのすべてを埋め込んでください。
1. 今後、SDK の最新バージョンに更新するには、以下のコマンドを実行します。
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### 手動のフレームワーク

1. Stripe の [GitHub リリースページ](https://github.com/stripe/stripe-ios/releases/latest)に移動して、**Stripe.xcframework.zip** をダウンロードして解凍します。
1. **StripePaymentsUI.xcframework** を、Xcode プロジェクトの **General (一般) ** 設定の **Embedded Binaries (埋め込みバイナリー)** セクションにドラッグします。**Copy items if needed (必要に応じてアイテムをコピーする)** を必ず選択してください。
1. [こちら](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking)にリストされている必要なフレームワークのすべてに対して、ステップ 2 を繰り返します。
1. 今後、Stripe の SDK の最新バージョンに更新するには、ステップ 1 から 3 を繰り返します。

> SDK の最新リリースおよび過去バージョンの詳細については、GitHub の [Releases (リリース)](https://github.com/stripe/stripe-ios/releases) ページをご覧ください。リポジトリの[リリースをウォッチ](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository)して、新しいリリースの公開時に通知を受け取ることも可能です。

アプリの起動時に Stripe [公開可能キー](https://dashboard.stripe.com/test/apikeys)を使用して SDK を設定します。これにより、アプリが Stripe API にリクエストを送信できるようになります。

#### Swift

```swift
import UIKitimportStripePaymentsUI

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

> テストおよび開発時には[テストキー](https://docs.stripe.com/keys.md#obtain-api-keys)を使用し、アプリの公開時には[本番環境](https://docs.stripe.com/keys.md#test-live-modes)キーを使用します。

## 連結アカウントを作成する

#### Accounts v2

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/v2/core/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

#### Accounts v1

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。
![](https://b.stripecdn.com/docs-statics-srv/assets/express-ios.6789c3d9f8e327847abb218d75a29eec.png)

> 本ガイドでは、特定の[制限](https://docs.stripe.com/connect/express-accounts.md#prerequisites-for-using-express)がある Express アカウントを使用します。代替案として、[Custom アカウント](https://docs.stripe.com/connect/custom-accounts.md)を検討することができます。

### 情報を事前入力して連結アカウントを作成する

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 支払い方法を有効にする

[支払い方法の設定](https://dashboard.stripe.com/settings/connect/payment_methods)を表示し、サポートする支払い方法を有効にします。カード支払い、Google Pay、Apple Pay はデフォルトで有効化されていますが、支払い方法は必要に応じて有効か無効かを設定できます。

決済フォームを表示する前に、Stripe は通貨、決済手段の制約、その他のパラメーターを評価し、対応可能な決済手段のリストを決定します。購入完了率の向上につながり、使用通貨と顧客の所在地に最も適した決済手段が、優先的に表示されます。優先度の低い決済手段は、オーバーフローメニューに隠れた状態になります。

## エンドポイントを追加する [サーバー側]

> #### 注
> 
> PaymentIntent の作成前に PaymentSheet を表示するには、[インテントを作成する前に支払いの詳細を収集する](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment)をご覧ください。

この接続方法では、以下の 3 つの Stripe API オブジェクトを使用します。

1. [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md): Stripe はこれを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して支払いの試行と支払い状態の変化を追跡します。

1. (オプション) [顧客設定アカウント](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) または [Customer](https://docs.stripe.com/api/customers.md) オブジェクト。今後の支払いに備えて決済手段を設定するには、顧客に関連付ける必要があります。顧客がビジネスでアカウントを作成するときに、顧客を表すオブジェクトを作成します。顧客がゲストとして支払いを行う場合は、支払いの前に `Account` または `Customer` オブジェクトを作成し、後で顧客のアカウントを表す独自の内部表現に関連付けることができます。

1. (オプション) [CustomerSession](https://docs.stripe.com/api/customer_sessions.md)。顧客を表すオブジェクトの情報は機密情報であるため、アプリから直接取得することはできません。`CustomerSession` により、SDK に `Account` または `Customer` への範囲を設定した一時的なアクセス権が付与され、追加の設定オプションも提供されます。すべての [設定オプション](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components) のリストをご覧ください。

> 顧客にカードを保存したことがなく、リピート顧客に保存されたカードの再利用を許可しない場合は、導入で `Account` または `Customer` オブジェクトおよび `CustomerSession` オブジェクトを省略できます。

セキュリティ上の理由により、アプリでこれらのオブジェクトを作成することはできません。代わりに、サーバー側で以下を行うエンドポイントを追加します。

1. `Account` または `Customer` を取得するか、新規作成します。
1. `Account` または `Customer` の [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) を作成します。
1. [金額](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount)、[通貨](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency)、および [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) または [customer](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer) を使用して `PaymentIntent` を作成します。
1. `PaymentIntent` の *Client Secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer))、`CustomerSession` の `client_secret`、`Account` または `Customer` の ID、およびアプリの [公開可能キー](https://dashboard.stripe.com/apikeys) を返します。

決済プロセス中に顧客に表示される支払い方法は、PaymentIntent にも含まれています。Stripe にダッシュボードの設定から支払い方法を取得するよう指定することも、手動でリストに表示することもできます。選択したオプションにかかわらず、顧客に表示される支払い方法は、PaymentIntent で渡す通貨によって絞り込まれることにご注意ください。たとえば、PaymentIntent で `eur` を渡し、ダッシュボードで OXXO が有効になっている場合、OXXO は `eur` による決済に対応していないため、顧客に表示されません。

構築済みのシステムで、決済手段を提供するためにコードベースのオプションが必要になる場合を除き、自動化されたオプションを使用することをお勧めします。これは、Stripe が通貨、決済手段の制約、その他のパラメーターを評価して、対応可能な決済手段を決定するためです。自動化されたオプションでは、購入完了率の向上につながり、使用通貨と顧客の所在地に最適な決済手段が優先的に表示されます。

#### ダッシュボードで支払い方法を管理する

支払い方法は[ダッシュボード](https://dashboard.stripe.com/settings/payment_methods)で管理できます。Stripe は取引額、通貨、決済フローなどの要素に基づいて、適切な支払い方法が返されるように処理します。PaymentIntent は、ダッシュボードで設定された支払い方法を使用して作成されます。ダッシュボードを使用しない場合や、支払い方法を手動で指定する場合は、`payment_method_types` 属性を使用して支払い方法を一覧表示することができます。

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### 支払い方法を手動で一覧表示する

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

> 各決済手段は PaymentIntent で渡された通貨に対応している必要があり、ビジネスは、各決済手段を使用できる国のいずれかに所在する必要があります。対応状況について、詳細は[決済手段の導入オプション](https://docs.stripe.com/payments/payment-methods/integration-options.md)ページをご覧ください。

## 決済画面を組み込む [クライアント側]

決済画面に Mobile Payment Element を表示するには、必ず以下を行ってください。

- 顧客が購入している商品を合計金額とともに表示する
- [Address Element](https://docs.stripe.com/elements/address-element.md?platform=ios) を使用して、必要な配送先情報を顧客から収集する
- Stripe の UI を表示する購入ボタンを追加する

#### UIKit

アプリの Checkout 画面で、前のステップで作成したエンドポイントから PaymentIntent の client Secret、CustomerSession の client Secret、顧客 ID、公開可能キーを取得します。`STPAPIClient.shared` を使用して公開可能キーを設定し、[PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html) を初期化します。

#### iOS (Swift)

```swift
import UIKit@_spi(CustomerSessionBetaAccess) import StripePaymentSheet

class CheckoutViewController: UIViewController {
  @IBOutlet weak var checkoutButton: UIButton!
  var paymentSheet: PaymentSheet?
  let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint

  override func viewDidLoad() {
    super.viewDidLoad()

    checkoutButton.addTarget(self, action: #selector(didTapCheckoutButton), for: .touchUpInside)
    checkoutButton.isEnabled = false

    // MARK: Fetch the PaymentIntent client secret, CustomerSession client secret, Customer ID, and publishable key
    var request = URLRequest(url: backendCheckoutUrl)
    request.httpMethod = "POST"
    let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in
      guard let data = data,
            let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
            let customerId = json["customer"] as? String,
            let customerSessionClientSecret = json["customerSessionClientSecret"] as? String,
            let paymentIntentClientSecret = json["paymentIntent"] as? String,
            let publishableKey = json["publishableKey"] as? String,
            let self = self else {
        // Handle error
        return
      }
STPAPIClient.shared.publishableKey = publishableKey// MARK: Create a PaymentSheet instance
      var configuration = PaymentSheet.Configuration()
      configuration.merchantDisplayName = "Example, Inc."
      configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret)
      // Set `allowsDelayedPaymentMethods` to true if your business handles
      // delayed notification payment methods like US bank accounts.
      configuration.allowsDelayedPaymentMethods = true
      self.paymentSheet = PaymentSheet(paymentIntentClientSecret:paymentIntentClientSecret, configuration: configuration)

      DispatchQueue.main.async {
        self.checkoutButton.isEnabled = true
      }
    })
    task.resume()
  }

}
```

顧客が**購入**ボタンをタップしたら、`present` を呼び出して PaymentSheet を表示します。顧客が支払いを完了したら、Stripe は PaymentSheet を閉じ、[PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html) とともに完了ブロックを呼び出します。

#### iOS (Swift)

```swift
@objc
func didTapCheckoutButton() {
  // MARK: Start the checkout process
  paymentSheet?.present(from: self) { paymentResult in
    // MARK: Handle the payment result
    switch paymentResult {
    case .completed:
      print("Your order is confirmed")
    case .canceled:
      print("Canceled!")
    case .failed(let error):
      print("Payment failed: \(error)")
    }
  }
}
```

#### SwiftUI

決済画面用の `ObservableObject` モデルを作成します。このモデルは、[PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html) と [PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html) を公開します。

```swift
import StripePaymentSheet
import SwiftUI

class CheckoutViewModel: ObservableObject {
  let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint
  @Published var paymentSheet: PaymentSheet?
  @Published var paymentResult: PaymentSheetResult?
}
```

前のステップで作成したエンドポイントから PaymentIntent の client secret、CustomerSession の client secret、顧客 ID、公開可能キーを取得します。`STPAPIClient.shared` を使用して公開可能キーを設定し、[PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html) を初期化します。

```swift
@_spi(CustomerSessionBetaAccess) import StripePaymentSheet
import SwiftUI

class CheckoutViewModel: ObservableObject {
  let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint
  @Published var paymentSheet: PaymentSheet?
  @Published var paymentResult: PaymentSheetResult?
func preparePaymentSheet() {
    // MARK: Fetch thePaymentIntent and Customer information from the backend
    var request = URLRequest(url: backendCheckoutUrl)
    request.httpMethod = "POST"
    let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in
      guard let data = data,
            let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
            let customerId = json["customer"] as? String,
            let customerSessionClientSecret = json["customerSessionClientSecret"] as? String,
            letpaymentIntentClientSecret = json["paymentIntent"] as? String,
            let publishableKey = json["publishableKey"] as? String,
            let self = self else {
        // Handle error
        return
      }

      STPAPIClient.shared.publishableKey = publishableKey// MARK: Create a PaymentSheet instance
      var configuration = PaymentSheet.Configuration()
      configuration.merchantDisplayName = "Example, Inc."
      configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret)
      // Set `allowsDelayedPaymentMethods` to true if your business handles
      // delayed notification payment methods like US bank accounts.
      configuration.allowsDelayedPaymentMethods = true

      DispatchQueue.main.async {
        self.paymentSheet = PaymentSheet(paymentIntentClientSecret:paymentIntentClientSecret, configuration: configuration)
      }
    })
    task.resume()
  }
}
struct CheckoutView: View {
  @ObservedObject var model = CheckoutViewModel()

  var body: some View {
    VStack {
      if model.paymentSheet != nil {
        Text("Ready to pay.")
      } else {
        Text("Loading…")
      }
    }.onAppear { model.preparePaymentSheet() }
  }
}
```

[PaymentSheet.PaymentButton](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/PaymentButton.html) を `View` に追加します。これは、SwiftUI の `Button` と同様に動作し、`View` を追加することでカスタマイズされます。ボタンをタップすると PaymentSheet が表示されます。支払いが完了すると、Stripe は PaymentSheet を閉じ、[PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html) オブジェクトとともに `onCompletion` ハンドラが呼び出されます。

```swift
@_spi(CustomerSessionBetaAccess) import StripePaymentSheet
import SwiftUI

class CheckoutViewModel: ObservableObject {
  let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint
  @Published var paymentSheet: PaymentSheet?
  @Published var paymentResult: PaymentSheetResult?

  func preparePaymentSheet() {
    // MARK: Fetch the PaymentIntent and Customer information from the backend
    var request = URLRequest(url: backendCheckoutUrl)
    request.httpMethod = "POST"
    let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in
      guard let data = data,
            let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
            let customerId = json["customer"] as? String,
            let customerSessionClientSecret = json["customerSessionClientSecret"] as? String,
            let paymentIntentClientSecret = json["paymentIntent"] as? String,
            let publishableKey = json["publishableKey"] as? String,
            let self = self else {
        // Handle error
        return
      }

      STPAPIClient.shared.publishableKey = publishableKey
      // MARK: Create a PaymentSheet instance
      var configuration = PaymentSheet.Configuration()
      configuration.merchantDisplayName = "Example, Inc."
      configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret)
      // Set `allowsDelayedPaymentMethods` to true if your business can handle payment methods
      // that complete payment after a delay, like SEPA Debit and Sofort.
      configuration.allowsDelayedPaymentMethods = true

      DispatchQueue.main.async {
        self.paymentSheet = PaymentSheet(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration)
      }
    })
    task.resume()
  }
func onPaymentCompletion(result: PaymentSheetResult) {
    self.paymentResult = result
  }
}

struct CheckoutView: View {
  @ObservedObject var model = CheckoutViewModel()

  var body: some View {
    VStack {if let paymentSheet = model.paymentSheet {
        PaymentSheet.PaymentButton(
          paymentSheet: paymentSheet,
          onCompletion: model.onPaymentCompletion
        ) {
          Text("Buy")
        }
      } else {
        Text("Loading…")
      }if let result = model.paymentResult {
        switch result {
        case .completed:
          Text("Payment complete")
        case .failed(let error):
          Text("Payment failed: \(error.localizedDescription)")
        case .canceled:
          Text("Payment canceled.")
        }
      }
    }.onAppear { model.preparePaymentSheet() }
  }
}
```

`PaymentSheetResult` が `.completed` の場合は、ユーザーに通知します (注文確認画面を表示するなど)。

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。

## 戻り先 URL を設定する [クライアント側]

顧客はお客様のアプリから離れて、(Safari やバンキングアプリなどで) 認証する場合があります。ユーザーが認証後にアプリに自動的に戻れるようにするには、[カスタム URL スキームを構成](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app)し、URL を SDK に転送するようにアプリのデリゲートを設定します。Stripe は[ユニバーサルリンク](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content)には対応していません。

#### SceneDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else {
        return
    }
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (!stripeHandled) {
        // This was not a Stripe url – handle the URL normally as you would
    }
}

```

#### AppDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (stripeHandled) {
        return true
    } else {
        // This was not a Stripe url – handle the URL normally as you would
    }
    return false
}
```

#### SwiftUI

#### Swift

```swift

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      Text("Hello, world!").onOpenURL { incomingURL in
          let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL)
          if (!stripeHandled) {
            // This was not a Stripe url – handle the URL normally as you would
          }
        }
    }
  }
}
```

## 支払い後のイベントを処理する [サーバー側]

支払いが完了すると、Stripe は [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) イベントを送信します。[ダッシュボードの Webhook ツール](https://dashboard.stripe.com/webhooks)を使用するか [Webhook のガイド](https://docs.stripe.com/webhooks/quickstart.md)に従ってこれらのイベントを受信し、顧客への注文確認メールの送信、データベースでの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアントでは、コールバックが実行される前に顧客がブラウザーのウィンドウを閉じたり、アプリを終了する場合、また悪意を持つクライアントがレスポンスを不正操作する場合もあります。非同期型のイベントをリッスンするよう組み込みを設定すると、単一の組み込みで[複数の異なるタイプの支払い方法](https://stripe.com/payments/payment-methods-guide)を受け付けることができます。

Payment Element を使用して支払いを回収する場合は、`payment_intent.succeeded` イベントのほかにこれらのイベントを処理することをお勧めします。

| イベント                                                                                                                            | 説明                                                                                                                                                                       | アクション                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded)           | 顧客が正常に支払いを完了したときに送信されます。                                                                                                                                                 | 顧客に注文の確定を送信し、顧客の注文の*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を実行します。 |
| [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing)         | 顧客が正常に支払いを開始したが、支払いがまだ完了していない場合に送信されます。このイベントは、多くの場合、顧客が口座引き落としを開始するときに送信されます。その後、`payment_intent.succeeded` イベント、また、失敗の場合は `payment_intent.payment_failed` イベントが送信されます。 | 顧客に注文確認メールを送信し、支払いが保留中であることを示します。デジタル商品では、支払いの完了を待たずに注文のフルフィルメントを行うことが必要になる場合があります。                                                                                |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | 顧客が支払いを試みたが、支払いに失敗する場合に送信されます。                                                                                                                                           | 支払いが `processing` から `payment_failed` に変わった場合は、顧客に再度支払いを試すように促します。                                                                                                 |

## 構築したシステムをテストする

#### カード

| カード番号               | シナリオ                                                                                                                                                                                                                                                                 | テスト方法                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| 4242424242424242    | カード支払いは成功し、認証は必要とされません。                                                                                                                                                                                                                                              | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000002500003155    | カード支払いには*認証* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase)が必要です。 | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000000000009995    | カードは、`insufficient_funds` などの拒否コードで拒否されます。                                                                                                                                                                                                                           | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 6205500000000000004 | UnionPay カードは、13 ～ 19 桁の可変長です。                                                                                                                                                                                                                                       | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |

#### 銀行へのリダイレクト

| 決済手段             | シナリオ                                                                                                             | テスト方法                                                                                                           |
| ---------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Bancontact、iDEAL | 顧客は、リダイレクトベースの即時通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | リダイレクトベースの任意の支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払い失敗)** をクリックします。           |
| Pay by Bank      | 顧客はリダイレクトベースの、[遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法で支払いに成功します。 | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Complete test payment (テスト支払い完了)** をクリックします。                    |
| Pay by Bank      | 顧客は、リダイレクトベースの遅延通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払いを失敗させる)** をクリックします。                    |
| BLIK             | BLIK による支払いはさまざまな理由で失敗します。即時の失敗 (コードの有効期限切れや無効など)、遅延型のエラー (銀行による拒否など)、またはタイムアウト (顧客が時間内に応答しなかったなど) などがあります。      | メールパターンを使用して[さまざまな失敗をシミュレーションします。](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures) |

#### 口座引き落とし

| 決済手段           | シナリオ                                                                         | テスト方法                                                                                                                   |
| -------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| SEPA ダイレクトデビット | 顧客が SEPA ダイレクトデビットによる支払いに成功しました。                                             | 口座番号 `AT321904300235473204` を使用して、フォームに入力します。確定された PaymentIntent のステータスはまず、processing に移行し、3 分後に succeeded ステータスに移行します。 |
| SEPA ダイレクトデビット | 顧客の Payment Intent のステータスが、`processing` から `requires_payment_method` に移行します。 | 口座番号 `AT861904300235473202` を使用して、フォームに入力します。                                                                           |

実装内容をテストするためのその他の情報については、[テスト](https://docs.stripe.com/testing.md)をご覧ください。

## Optional: Apple Pay を有効にする

> 決済画面に専用の **Apple Pay** ボタンがある場合は、[Apple Pay ガイド](https://docs.stripe.com/apple-pay.md#present-payment-sheet)に従い、`ApplePayContext` を使用して Apple Pay ボタンからの支払いを回収します。その他の種類の支払い方法を処理するには、`PaymentSheet` を使用できます。

### Apple 加盟店 ID を登録する

Apple Developer Web サイトで [新規 ID を登録](https://developer.apple.com/account/resources/identifiers/add/merchant) して、Apple 加盟店 ID を取得します。

フォームに説明と ID を入力します。説明はお客様の記録用であり、後で変更できます。アプリの名前を ID として使用することをお勧めします (`merchant.com.{{YOUR_APP_NAME}}` など)。

### 新しい Apple Pay 証明書を作成する

支払いデータを暗号化するためのアプリの証明書を作成します。

ダッシュボードの [iOS certificate settings (iOS 証明書の設定)](https://dashboard.stripe.com/settings/ios_certificates) に移動して、**新規アプリケーションを追加**をクリックし、表示されるガイドに従います。

証明書署名リクエスト (CSR) ファイルをダウンロードして、Apple Pay の利用を可能にする安全な証明書を Apple から取得します。

1 つの CSR ファイルを使用して証明書を 1 つだけ発行する必要があります。Apple 加盟店 ID を切り替えた場合、ダッシュボードの [iOS Certificate Settings (iOS 証明書の設定)](https://dashboard.stripe.com/settings/ios_certificates) に移動して、新しい CSR と証明書を取得する必要があります。

### Xcode を使用して組み込む

Apple Pay ケイパビリティをアプリに追加します。Xcode でプロジェクト設定を開き、**Signing & Capabilities (署名およびケイパビリティ)** タブを選択して、**Apple Pay** ケイパビリティを追加します。この段階で開発者アカウントへのログインを要求される場合があります。前の手順で作成した加盟店 ID を選択すると、アプリで Apple Pay を受け付けられるようになります。
![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png)

Xcode で Apple Pay ケイパビリティを有効化する

### Apple Pay を追加する

#### 1 回限りの支払い

Apple Pay を PaymentSheet に追加するには、Apple 加盟店 ID と[お客様のビジネスの国コード](https://dashboard.stripe.com/settings/account)で `PaymentSheet.Configuration` を初期化してから、[applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp) を設定します。

#### iOS (Swift)

```swift
var configuration = PaymentSheet.Configuration()
configuration.applePay = .init(
  merchantId: "merchant.com.your_app_name",
  merchantCountryCode: "US"
)
```

#### 継続支払い

Apple Pay を PaymentSheet に追加するには、Apple 加盟店 ID と[お客様のビジネスの国コード](https://dashboard.stripe.com/settings/account)で `PaymentSheet.Configuration` を初期化してから、[applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp) を設定します。

継続支払いに関する [Apple のガイドライン](https://developer.apple.com/design/human-interface-guidelines/apple-pay#Supporting-subscriptions)に従い、`PKPaymentRequest` で追加の属性を設定する必要もあります。[ApplePayConfiguration.paymentRequestHandlers](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/paymentrequesthandler) にハンドラーを追加して、請求する予定の金額 (たとえば月額 9.95 USD) を指定して [PKPaymentRequest.paymentSummaryItems](https://developer.apple.com/documentation/passkit/pkpaymentrequest/1619231-paymentsummaryitems) を設定します。

`PKPaymentRequest` で `recurringPaymentRequest` または `automaticReloadPaymentRequest` プロパティを設定することで、[加盟店トークン](https://developer.apple.com/apple-pay/merchant-tokens/)を導入することもできます。

Apple Pay で継続支払いを使用する方法の詳細については、[Apple の PassKit に関するドキュメント](https://developer.apple.com/documentation/passkit/pkpaymentrequest)をご覧ください。

#### iOS (Swift)

```swift
let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers(
    paymentRequestHandler: { request in
        // PKRecurringPaymentSummaryItem is available on iOS 15 or later
        if #available(iOS 15.0, *) {
            let billing = PKRecurringPaymentSummaryItem(label: "My Subscription", amount: NSDecimalNumber(string: "59.99"))

            // Payment starts today
            billing.startDate = Date()

            // Payment ends in one year
            billing.endDate = Date().addingTimeInterval(60 * 60 * 24 * 365)

            // Pay once a month.
            billing.intervalUnit = .month
            billing.intervalCount = 1

            // recurringPaymentRequest is only available on iOS 16 or later
            if #available(iOS 16.0, *) {
                request.recurringPaymentRequest = PKRecurringPaymentRequest(paymentDescription: "Recurring",
                                                                            regularBilling: billing,
                                                                            managementURL: URL(string: "https://my-backend.example.com/customer-portal")!)
                request.recurringPaymentRequest?.billingAgreement = "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'"
            }
            request.paymentSummaryItems = [billing]
            request.currencyCode = "USD"
        } else {
            // On older iOS versions, set alternative summary items.
            request.paymentSummaryItems = [PKPaymentSummaryItem(label: "Monthly plan starting July 1, 2022", amount: NSDecimalNumber(string: "59.99"), type: .final)]
        }
        return request
    }
)
var configuration = PaymentSheet.Configuration()
configuration.applePay = .init(merchantId: "merchant.com.your_app_name",
                                merchantCountryCode: "US",
                                customHandlers: customHandlers)
```

### 注文の追跡

iOS 16 以降で[注文の追跡](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking)情報を追加するには、`PaymentSheet.ApplePayConfiguration.Handlers` で [authorizationResultHandler](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/authorizationresulthandler) を設定します。支払いの完了後、Stripe は iOS が Apple Pay の決済画面を閉じる前に実装を呼び出します。

`authorizationResultHandler` の実装で、完了した注文の注文の詳細をサーバーから取得します。提供された [PKPaymentAuthorizationResult](https://developer.apple.com/documentation/passkit/pkpaymentauthorizationresult) に詳細を追加し、変更された結果を返します。

注文の追跡の詳細については、[Apple のウォレットでの注文に関するドキュメント](https://developer.apple.com/documentation/walletorders)をご覧ください。

#### iOS (Swift)

```swift
let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers(
    authorizationResultHandler: { result in
      do {
        // Fetch the order details from your service
        let myOrderDetails = try await MyAPIClient.shared.fetchOrderDetails(orderID: orderID)
        result.orderDetails = PKPaymentOrderDetails(
          orderTypeIdentifier: myOrderDetails.orderTypeIdentifier, // "com.myapp.order"
          orderIdentifier: myOrderDetails.orderIdentifier, // "ABC123-AAAA-1111"
          webServiceURL: myOrderDetails.webServiceURL, // "https://my-backend.example.com/apple-order-tracking-backend"
          authenticationToken: myOrderDetails.authenticationToken) // "abc123"
        // Return your modified PKPaymentAuthorizationResult
        return result
      } catch {
        return PKPaymentAuthorizationResult(status: .failure, errors: [error])
      }
    }
)
var configuration = PaymentSheet.Configuration()
configuration.applePay = .init(merchantId: "merchant.com.your_app_name",
                               merchantCountryCode: "US",
                               customHandlers: customHandlers)
```

## カードのスキャンを有効にする

iOS をサポートするカードスキャン機能を有効にするには、アプリケーションの `Info.plist` の `NSCameraUsageDescription` (**プライバシー - カメラ利用の詳細**)を設定し、カメラにアクセスする理由を入力して下さい (例:「カードをスキャンするため」)。

## Optional: 画面をカスタマイズする

カスタマイズはすべて、[PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html) オブジェクトで設定されます。

### デザイン

色やフォントなどをアプリの見た目や雰囲気に合わせてカスタマイズするには、[appearance API](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=ios) を使用します。

### 決済手段のレイアウト

[paymentMethodLayout](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/configuration-swift.struct/paymentmethodlayout) を使用して、画面上の決済手段のレイアウトを設定します。横や縦に表示することも、Stripe がレイアウトを自動で最適化するように設定することもできます。
![](https://b.stripecdn.com/docs-statics-srv/assets/ios-mpe-payment-method-layouts.9d0513e2fcec5660378ba1824d952054.png)

#### Swift

```swift
var configuration = PaymentSheet.Configuration()
configuration.paymentMethodLayout = .automatic
```

### ユーザーの住所を収集する

[Address Element](https://docs.stripe.com/elements/address-element.md?platform=ios) を使用して、顧客から国内および国外の配送先住所や請求先住所を収集します。

### 加盟店の表示名

[merchantDisplayName](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV19merchantDisplayNameSSvp) を設定し、顧客に表示するビジネス名を指定します。デフォルトではアプリ名になります。

#### Swift

```swift
var configuration = PaymentSheet.Configuration()
configuration.merchantDisplayName = "My app, Inc."
```

### ダークモード

`PaymentSheet` は、ユーザーのシステム全体の表示設定 (ライト / ダークモード) に合わせて自動的に調整されます。アプリがダークモードに対応していない場合は、[style](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV5styleAC18UserInterfaceStyleOvp) を `alwaysLight` または `alwaysDark` モードに設定できます。

```swift
var configuration = PaymentSheet.Configuration()
configuration.style = .alwaysLight
```

### デフォルトの請求詳細

支払い画面で収集される請求詳細のデフォルト値を設定するには、`defaultBillingDetails` プロパティーを設定します。`PaymentSheet` の各フィールドに、指定したそれらの値が事前に読み込まれます。

```swift
var configuration = PaymentSheet.Configuration()
configuration.defaultBillingDetails.address.country = "US"
configuration.defaultBillingDetails.email = "foo@bar.com"
```

### 請求の詳細の収集

`billingDetailsCollectionConfiguration` を使用して、決済画面で請求の詳細を収集する方法を指定します。

顧客の名前、メールアドレス、電話番号、住所を収集できます。

支払い方法で必須の請求詳細のみを収集する場合は、`billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` を true に設定します。その場合、`PaymentSheet.Configuration.defaultBillingDetails` が支払い方法の[請求詳細](https://docs.stripe.com/api/payment_methods/object.md?lang=node#payment_method_object-billing_details)として設定されます。

支払い方法で必ずしも必須ではない追加の請求詳細を収集する場合は、`billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` を false に設定します。 その場合、`PaymentSheet` で収集した請求詳細が支払い方法の請求詳細として設定されます。

```swift
var configuration = PaymentSheet.Configuration()
configuration.defaultBillingDetails.email = "foo@bar.com"
configuration.billingDetailsCollectionConfiguration.name = .always
configuration.billingDetailsCollectionConfiguration.email = .never
configuration.billingDetailsCollectionConfiguration.address = .full
configuration.billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod = true
```

> 情報の収集に適用される法律については、弁護士に相談してください。電話番号は、取引に必要な場合にのみ収集してください。

## Optional: UI で支払いを完了する

支払い方法の詳細を収集するためにのみ支払い画面を表示して、後で `confirm` メソッドを呼び出して、アプリの UI で支払いを完了できます。これは、カスタムの購入ボタンがある場合や、支払いの詳細を収集した後で追加のステップが必要な場合に便利です。
![](https://b.stripecdn.com/docs-statics-srv/assets/ios-multi-step.cd631ea4f1cd8cf3f39b6b9e1e92b6c5.png)

アプリの UI で支払いを完了する

#### UIKit

以下のステップでは、アプリの UI で支払いを完了する方法を説明します。[GitHub](https://github.com/stripe/stripe-ios/blob/master/Example/PaymentSheet%20Example/PaymentSheet%20Example/ExampleCustomCheckoutViewController.swift) でサンプルの実装をご覧下さい。

1. 最初に、`PaymentSheet` ではなく、[PaymentSheet.FlowController](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller) を初期化し、その `paymentOption` プロパティで UI を更新します。このプロパティには、顧客が最初に選択したデフォルトの支払い方法を表す画像とラベルが含まれています。

```swift
PaymentSheet.FlowController.create(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration) { [weak self] result in
  switch result {
  case .failure(let error):
    print(error)
  case .success(let paymentSheetFlowController):
    self?.paymentSheetFlowController = paymentSheetFlowController
    // Update your UI using paymentSheetFlowController.paymentOption
  }
}
```

1. 次に、`presentPaymentOptions` を呼び出し、支払いの詳細を収集します。完了したら、`paymentOption` プロパティで再度 UI を更新します。

```swift
paymentSheetFlowController.presentPaymentOptions(from: self) {
  // Update your UI using paymentSheetFlowController.paymentOption
}
```

1. 最後に、`confirm` を呼び出します。

```swift
paymentSheetFlowController.confirm(from: self) { paymentResult in
  // MARK: Handle the payment result
  switch paymentResult {
  case .completed:
    print("Payment complete!")
  case .canceled:
    print("Canceled!")
  case .failed(let error):
    print(error)
  }
}
```

#### SwiftUI

以下のステップでは、アプリの UI で支払いを完了する方法を説明します。[GitHub](https://github.com/stripe/stripe-ios/blob/master/Example/PaymentSheet%20Example/PaymentSheet%20Example/ExampleSwiftUICustomPaymentFlow.swift) でサンプルの実装をご覧下さい。

1. 最初に、`PaymentSheet` ではなく、[PaymentSheet.FlowController](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller) を初期化します。その `paymentOption` プロパティには、顧客が現在選択している支払い方法を表す画像とラベルが含まれており、これを UI で使用することができます。

```swift
PaymentSheet.FlowController.create(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration) { [weak self] result in
  switch result {
  case .failure(let error):
    print(error)
  case .success(let paymentSheetFlowController):
    self?.paymentSheetFlowController = paymentSheetFlowController
    // Use the paymentSheetFlowController.paymentOption properties in your UI
    myPaymentMethodLabel = paymentSheetFlowController.paymentOption?.label ?? "Select a payment method"
    myPaymentMethodImage = paymentSheetFlowController.paymentOption?.image ?? UIImage(systemName: "square.and.pencil")!
  }
}
```

1. [PaymentSheet.FlowController.PaymentOptionsButton](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller/paymentoptionsbutton) を使用して、支払いの詳細を収集するための画面を表示するボタンをラップします。`PaymentSheet.FlowController` が `onSheetDismissed` 引数を呼び出すと、`PaymentSheet.FlowController` インスタンスの `paymentOption` に現在選択されている支払い方法が反映されます。

```swift
PaymentSheet.FlowController.PaymentOptionsButton(
  paymentSheetFlowController: paymentSheetFlowController,
  onSheetDismissed: {
    myPaymentMethodLabel = paymentSheetFlowController.paymentOption?.label ?? "Select a payment method"
    myPaymentMethodImage = paymentSheetFlowController.paymentOption?.image ?? UIImage(systemName: "square.and.pencil")!
  },
  content: {
    /* An example button */
    HStack {
      Text(myPaymentMethodLabel)
      Image(uiImage: myPaymentMethodImage)
    }
  }
)
```

1. [PaymentSheet.FlowController.PaymentOptionsButton](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller/paymentoptionsbutton) を使用して、支払いを確定するボタンをラップします。

```swift
PaymentSheet.FlowController.ConfirmButton(
  paymentSheetFlowController: paymentSheetFlowController,
  onCompletion: { result in
    // MARK: Handle the payment result
    switch result {
    case .completed:
      print("Payment complete!")
    case .canceled:
      print("Canceled!")
    case .failed(let error):
      print(error)
    }
  },
  content: {
    /* An example button */
    Text("Pay")
  }
)
```

`PaymentSheetResult` が `.completed` の場合は、ユーザーに通知します (注文確認画面を表示するなど)。

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。


# カード Element のみ

> This is a カード Element のみ for when platform is ios and mobile-ui is card-element. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=ios&mobile-ui=card-element.

SDK が提供し、カード番号、有効期限、セキュリティコード、郵便番号を収集するドロップイン UI コンポーネントである [STPPaymentCardTextField](https://stripe.dev/stripe-ios/stripe-payments-ui/Classes/STPPaymentCardTextField.html) を使用して、クライアント側でカード情報を安全に収集します。
![](https://d37ugbyn3rpeym.cloudfront.net/docs/mobile/ios/card-field.mp4)
このガイドは、決済を受け付け、売上を売り手やサービスプロバイダーの銀行口座に移動する方法をデモンストレーションします。デモンストレーションでは、住宅所有者とレンタル物件を探す人を結びつける住宅賃貸のマーケットプレイスを構築します。このガイドで扱われる概念を他のアプリケーションにも適用することができます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバ側] [クライアント側]

まず、Stripe アカウントが必要です。[今すぐ登録](https://dashboard.stripe.com/register)してください。

### サーバ側

この組み込みには、サーバ上に Stripe API と通信するエンドポイントが必要です。サーバから Stripe API にアクセスするには、Stripe の公式ライブラリを使用します。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### クライアント側

[Stripe iOS SDK](https://github.com/stripe/stripe-ios) はオープンソースです。[詳細なドキュメントが提供されており](https://stripe.dev/stripe-ios/index.html)、iOS 13 以降をサポートするアプリと互換性があります。

#### Swift Package Manager

SDK をインストールするには、以下のステップに従います。

1. Xcode で、**File (ファイル)** > **Add Package Dependencies… (パッケージ依存関係を追加)** を選択し、リポジトリー URL として `https://github.com/stripe/stripe-ios-spm` を入力します。
1. [リリースページ](https://github.com/stripe/stripe-ios/releases)から最新のバージョン番号を選択します。
1. **StripePaymentsUI** 製品を[アプリのターゲット](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app)に追加します。

#### CocoaPods

1. まだインストールしていない場合は、[CocoaPods](https://guides.cocoapods.org/using/getting-started.html) の最新バージョンをインストールします。
1. 既存の [Podfile](https://guides.cocoapods.org/syntax/podfile.html) がない場合は、以下のコマンドを実行して作成します。
   ```bash
   pod init
   ```
1. この行を `Podfile` に追加します。
   ```podfile
   pod 'StripePaymentsUI'
   ```
1. 以下のコマンドを実行します。
   ```bash
   pod install
   ```
1. これ以降は、Xcode でプロジェクトを開く際に、`.xcodeproj` ファイルではなく、必ず `.xcworkspace` ファイルを使用するということを忘れないでください。
1. 今後、SDK の最新バージョンに更新するには、以下を実行します。
   ```bash
   pod update StripePaymentsUI
   ```

#### Carthage

1. まだインストールしていない場合は、[Carthage](https://github.com/Carthage/Carthage#installing-carthage) の最新バージョンをインストールします。
1. この行を `Cartfile` に追加します。
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. [Carthage のインストール手順](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos)に従います。必ず、[こちら](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking)にリストされている必要なフレームワークのすべてを埋め込んでください。
1. 今後、SDK の最新バージョンに更新するには、以下のコマンドを実行します。
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### 手動のフレームワーク

1. Stripe の [GitHub リリースページ](https://github.com/stripe/stripe-ios/releases/latest)に移動して、**Stripe.xcframework.zip** をダウンロードして解凍します。
1. **StripePaymentsUI.xcframework** を、Xcode プロジェクトの **General (一般) ** 設定の **Embedded Binaries (埋め込みバイナリー)** セクションにドラッグします。**Copy items if needed (必要に応じてアイテムをコピーする)** を必ず選択してください。
1. [こちら](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking)にリストされている必要なフレームワークのすべてに対して、ステップ 2 を繰り返します。
1. 今後、Stripe の SDK の最新バージョンに更新するには、ステップ 1 から 3 を繰り返します。

> SDK の最新リリースおよび過去バージョンの詳細については、GitHub の [Releases (リリース)](https://github.com/stripe/stripe-ios/releases) ページをご覧ください。リポジトリの[リリースをウォッチ](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository)して、新しいリリースの公開時に通知を受け取ることも可能です。

アプリの起動時に Stripe [公開可能キー](https://dashboard.stripe.com/test/apikeys)を使用して SDK を設定します。これにより、アプリが Stripe API にリクエストを送信できるようになります。

#### Swift

```swift
import UIKitimportStripePaymentsUI

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

> テストおよび開発時には[テストキー](https://docs.stripe.com/keys.md#obtain-api-keys)を使用し、アプリの公開時には[本番環境](https://docs.stripe.com/keys.md#test-live-modes)キーを使用します。

## 連結アカウントを作成する

#### Accounts v2

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/v2/core/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

#### Accounts v1

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。
![](https://b.stripecdn.com/docs-statics-srv/assets/express-ios.6789c3d9f8e327847abb218d75a29eec.png)

> 本ガイドでは、特定の[制限](https://docs.stripe.com/connect/express-accounts.md#prerequisites-for-using-express)がある Express アカウントを使用します。代替案として、[Custom アカウント](https://docs.stripe.com/connect/custom-accounts.md)を検討することができます。

### 情報を事前入力して連結アカウントを作成する

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 決済を受け付ける

### ステップ 3.1: 決済ページを作成する (クライアント側)

SDK が提供し、カード番号、有効期限、セキュリティコード、郵便番号を収集するドロップイン UI コンポーネントである [STPPaymentCardTextField](https://stripe.dev/stripe-ios/stripe-payments-ui/Classes/STPPaymentCardTextField.html) を使用して、クライアント側でカード情報を安全に収集します。
![](https://d37ugbyn3rpeym.cloudfront.net/docs/mobile/ios/card-field.mp4)
以下のコードを使用し、カードコンポーネントのインスタンスを作成し、**支払い** ボタンを作成します。

#### Swift

```swift
import UIKit
import StripePaymentsUI

class CheckoutViewController: UIViewController {

    lazy var cardTextField: STPPaymentCardTextField = {
        let cardTextField = STPPaymentCardTextField()
        return cardTextField
    }()
    lazy var payButton: UIButton = {
        let button = UIButton(type: .custom)
        button.layer.cornerRadius = 5
        button.backgroundColor = .systemBlue
        button.titleLabel?.font = UIFont.systemFont(ofSize: 22)
        button.setTitle("Pay", for: .normal)
        button.addTarget(self, action: #selector(pay), for: .touchUpInside)
        return button
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        let stackView = UIStackView(arrangedSubviews: [cardTextField, payButton])
        stackView.axis = .vertical
        stackView.spacing = 20
        stackView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(stackView)
        NSLayoutConstraint.activate([
            stackView.leftAnchor.constraint(equalToSystemSpacingAfter: view.leftAnchor, multiplier: 2),
            view.rightAnchor.constraint(equalToSystemSpacingAfter: stackView.rightAnchor, multiplier: 2),
            stackView.topAnchor.constraint(equalToSystemSpacingBelow: view.topAnchor, multiplier: 2),
        ])
    }

    @objc
    func pay() {
        // ...
    }
}
```

アプリを実行し、決済ページにカードコンポーネントと支払いボタンが表示されることを確認します。

### ステップ 3.2: PaymentIntent を作成する (サーバー側) (クライアント側)

Stripe は [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md) オブジェクトを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して請求の実施と支払い状態の変化を追跡します。

### サーバ側

サーバーで、[amount](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) と [currency](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency) を指定して PaymentIntent を作成するエンドポイントを設定します。支払い金額は、クライアント側ではなく、常に信頼できる環境のサーバー側で指定してください。これにより、悪意のある顧客が金額を恣意的に選択できないようにします。

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d amount=1000 \
  -d currency="usd" \
  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_STRIPE_ACCOUNT_ID}}"
```

住宅賃貸の例では、顧客が Stripe プラットフォームを使用して賃借料を支払い、Stripe が顧客の賃貸料を住宅所有者に支払うビジネスを構築します。このビジネスを設定するには、次の手順に従います。

- `transfer_data[destination]` で、賃借料がデスティネーション支払いであることを示す。
- `application_fee_amount` で、賃借料の内、プラットフォームに送られる金額を指定する。

賃借料の支払いが行われたら、Stripe は連結アカウントの保留中の残高 (`transfer_data[destination]`) に全額送金します。その後、Stripe は手数料の金額 (`application_fee_amount`) をプラットフォームのアカウントに送金します。これは賃貸事業を支えるレベニューシェアです。その後、Stripe はプラットフォームの手数料の金額から Stripe 手数料を差し引きます。この資金フローを以下の図で示しています。
![](https://b.stripecdn.com/docs-statics-srv/assets/application_fee_amount.837aa2339469b3c1a4319672971c1367.svg)

> この PaymentIntent は、デスティネーション支払いを作成します。送金のタイミングを管理したり、1 回の支払いの売上を複数の当事者に送金したりする必要がある場合は、代わりに[支払いと送金別方式](https://docs.stripe.com/connect/separate-charges-and-transfers.md)を使用してください。

アプリケーションに PaymentIntent オブジェクト全体を渡す代わりに、*client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) のみを返してください。PaymentIntent のクライアントシークレットは、支払いを確認したりクライアント上でカード情報を更新したりするための固有キーであり、支払金額などの機密情報を操作されることを防ぎます。

### クライアント側

クライアント側で、サーバーの PaymentIntent をリクエストし、その *client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) を保存します。

#### Swift

```swift
class CheckoutViewController: UIViewController {
    var paymentIntentClientSecret: String?

    // ...continued from previous step

    override func viewDidLoad() {
        // ...continued from previous step
        startCheckout()
    }

    func startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
        // Click View full sample to see a complete implementation
    }
}
```

### ステップ 3.3: Stripe に支払いを送金する (クライアント側)

顧客が**支払い**ボタンをタップしたら、支払いを完了するために `PaymentIntent` を*確定* (Confirming a PaymentIntent indicates that the customer intends to pay with the current or provided payment method. Upon confirmation, the PaymentIntent attempts to initiate a payment)します。

まず、以下を使用して [STPPaymentIntentParams](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentIntentParams.html) オブジェクトを作成します。

1. カードのテキストフィールドの支払い方法詳細
1. サーバから取得した `PaymentIntent` client secret

PaymentIntent オブジェクト全体をクライアントに送信するのではなく、その *client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) を使用します。これは、Stripe API リクエストを認証する API キーとは異なります。client secret は、アプリで機密情報を含むフィールド (`customer` など) を非表示にしながら、PaymentIntent の重要なフィールド (`status` など) にアクセスできるようにする文字列です。

client secret は支払いを完了できるため、慎重に取り扱う必要があります。記録したり、URL に埋め込んだり、当該の顧客以外に漏洩することがないようにしてください。

次に、 [STPPaymentHandler confirmPayment](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:) メソッドを呼び出して、支払いを完了します。

#### Swift

```swift
class CheckoutViewController: UIViewController {

    // ...

    @objc
    func pay() {
        guard let paymentIntentClientSecret = paymentIntentClientSecret else {
            return
        }
        // Collect card details
        let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)
        paymentIntentParams.paymentMethodParams = cardTextField.paymentMethodParams

        // Submit the payment
        let paymentHandler = STPPaymentHandler.shared()
        paymentHandler.confirmPayment(paymentIntentParams, with: self) { (status, paymentIntent, error) in
            switch (status) {
            case .failed:
                self.displayAlert(title: "Payment failed", message: error?.localizedDescription ?? "")
                break
            case .canceled:
                self.displayAlert(title: "Payment canceled", message: error?.localizedDescription ?? "")
                break
            case .succeeded:
                self.displayAlert(title: "Payment succeeded", message: paymentIntent?.description ?? "", restartDemo: true)
                break
            @unknown default:
                fatalError()
                break
            }
        }
    }
}

extension CheckoutViewController: STPAuthenticationContext {
    func authenticationPresentingViewController() -> UIViewController {
        return self
    }
}
```

`PaymentIntent` に `setupFutureUsage` と `customer` の両方を指定することで、支払い確定時に[顧客の支払いカードの詳細を保存](https://docs.stripe.com/payments/payment-intents.md#future-usage)できます。サーバーで `PaymentIntent` を作成する際にも、これらのパラメーターを指定できます。

アプリケーションに適した `setupFutureUsage` 値を設定するには、顧客による追加の認証ステップが必要になる場合がありますが、今後支払いが銀行によって拒否される確率を減らすことができます。[今後の支払いのためにカードを最適化する方法を確認](https://docs.stripe.com/payments/payment-intents.md#future-usage)し、アプリケーションに使用する値を決定します。

| 予定しているカードの使用方法                                                                                                                                                      | `setup_future_usage` 列挙値 |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| *オンセッション* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method)支払いのみ | `on_session`             |
| *オフセッション* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method)支払いのみ | `off_session`            |
| オンセッション支払いとオフセッション支払いの両方                                                                                                                                            | `off_session`            |

オンセッション支払い用に設定されたカードをオフセッション支払いに使用することもできますが、銀行がオフセッション支払いを拒否し、カード保有者に認証を求める可能性が高くなります。

[強力な顧客認証 (SCA)](https://docs.stripe.com/strong-customer-authentication.md) などの規制によって認証が要求される場合、`STPPaymentHandler` は渡された [STPAuthenticationContext](https://stripe.dev/stripe-ios/stripe-payments/Protocols/STPAuthenticationContext.html) を使用してビューコントローラーを表示し、そのプロセスをステップごとに顧客に提示します。[iOS で 3D セキュア認証に対応する方法を確認してください](https://docs.stripe.com/payments/3d-secure.md?platform=ios)。

支払いが成功した場合、完了ハンドラが `.succeeded` ステータスで呼び出されます。失敗した場合、ステータスは `.failed` となり、ユーザに `error.localizedDescription` を表示できます。

`PaymentIntent` のステータスは、[ダッシュボード](https://dashboard.stripe.com/test/payments)で確認できるほか、オブジェクトの `status` プロパティを調べることでも確認できます。

### ステップ 3.4: 実装内容をテストする (クライアント側)

​​この実装の準備ができていることを確認するために、サンドボックスで使用できるテストカードがいくつかあります。任意のセキュリティコードおよび将来の有効期限を指定して使用します。

| 番号               | 説明                                      |
| ---------------- | --------------------------------------- |
| 4242424242424242 | 支払いが成功し、すぐに処理されます。                      |
| 4000002500003155 | 認証が必要です。Stripe は、顧客に認証を求めるモーダルをトリガーします。 |
| 4000000000009995 | 常に支払い拒否コード `insufficient_funds` で失敗します。 |

テストカードの一覧については、[テスト](https://docs.stripe.com/testing.md)に関するガイドを参照してください。

### ステップ 3.5: フルフィルメントを実行する (サーバー側)

支払いの完了後、お客様側で必要な*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を処理する必要があります。たとえば、前払いを必要とする住宅賃貸会社は、支払いが成功した後に、住宅所有者と賃借人を関連付けます。

[ダッシュボード](https://dashboard.stripe.com/account/webhooks)で (「お客様のアカウントから」イベント用に) *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) エンドポイントを構成します。
![](https://b.stripecdn.com/docs-statics-srv/assets/account_webhooks.03b71cec87ef2093fe0caa92e5bfce44.png)

次に、お客様のサーバ上に HTTP エンドポイントを作成し、完了した支払いを監視し、売り手またはサービスプロバイダが購入内容をフルフィルメントできるようにします。サンプルのエンドポイントシークレットキー (`whsec_...`) は、必ず各自のキーに置き換えてください。

#### Ruby

```ruby
# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
# Find your keys at https://dashboard.stripe.com/apikeys.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

# If you are testing your webhook locally with the Stripe CLI you
# can find the endpoint's secret by running `stripe listen`
# Otherwise, find your endpoint's secret in your webhook settings in
# the Developer Dashboard
endpoint_secret = 'whsec_...'

post '/webhook' do
  payload = request.body.read
  sig_header = request.env['HTTP_STRIPE_SIGNATURE']

  event = nil
# Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks#verify-events for more information.
  begin
    event = Stripe::Webhook.construct_event(
      payload, sig_header, endpoint_secret
    )
  rescue JSON::ParserError => e
    # Invalid payload.
    status 400
    return
  rescue Stripe::SignatureVerificationError => e
    # Invalid Signature.
    status 400
    return
  end

  if event['type'] == 'payment_intent.succeeded'
    payment_intent = event['data']['object']
    handle_successful_payment_intent(payment_intent)
  end

  status 200
end

def handle_successful_payment_intent(payment_intent)
  # Fulfill the purchase
  puts payment_intent.to_s
end
```

[決済向けフルフィルメントガイド](https://docs.stripe.com/webhooks/handling-payment-events.md)で詳細をご確認ください。

### Webhook をローカルでテストする

Stripe CLI を使用すると、Webhook をローカルでテストできます。

1. まず、[Stripe CLI をインストール](https://docs.stripe.com/stripe-cli/install.md)していない場合は、マシンにインストールしてください。

1. 次に、ログインするために、コマンドラインで `stripe login` を実行し、手順に従います。

1. 最後に、連結アカウントでシミュレートされたイベントをローカルホストで受信できるようにするために、1 つの端末ウィンドウで `stripe listen --forward-to localhost:{PORT}/webhook` を実行し、別の端末ウィンドウで `stripe trigger --stripe-account={{CONNECTED_STRIPE_ACCOUNT_ID}} payment_intent.succeeded` を実行します (あるいはその他の[サポートされているイベント](https://github.com/stripe/stripe-cli/wiki/trigger-command#supported-events)をトリガーします) 。

### ステップ 3.6: 不審請求の申請

お客様は支払いの[売上処理加盟店](https://docs.stripe.com/connect/destination-charges.md#settlement-merchant)であるため、お客様のプラットフォームは不審請求の申請に対する責任を負います。不審請求の申請に対応するための[ベストプラクティス](https://docs.stripe.com/disputes/responding.md)を必ず理解するようにしてください。

## テスト

[アカウントを作成](https://docs.stripe.com/connect/testing.md#creating-accounts)し、[OAuth を使用](https://docs.stripe.com/connect/testing.md#using-oauth)して、アカウント作成フローをテストします。[利用可能なテストカード](https://docs.stripe.com/testing.md)を使用して、支払いフローをテストし、さまざまな支払い結果をシミュレーションできます。


# 決済画面

> This is a 決済画面 for when platform is android and mobile-ui is payment-element. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=android&mobile-ui=payment-element.
![](https://b.stripecdn.com/docs-statics-srv/assets/android-overview.471eaf89a760f5b6a757fd96b6bb9b60.png)

[PaymentSheet](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html) クラスを使用して、Stripe の構築済み決済 UI を Android アプリの決済フローに組み込みます。

このガイドは、決済を受け付け、売上を売り手やサービスプロバイダーの銀行口座に移動する方法をデモンストレーションします。デモンストレーションでは、住宅所有者とレンタル物件を探す人を結びつける住宅賃貸のマーケットプレイスを構築します。このガイドで扱われる概念を他のアプリケーションにも適用することができます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバ側] [クライアント側]

まず、Stripe アカウントが必要です。[今すぐ登録](https://dashboard.stripe.com/register)してください。

### サーバ側

この組み込みには、サーバ上に Stripe API と通信するエンドポイントが必要です。サーバから Stripe API にアクセスするには、Stripe の公式ライブラリを使用します。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### クライアント側

[Stripe Android SDK](https://github.com/stripe/stripe-android) はオープンソースであり、[詳細なドキュメントが提供されています](https://stripe.dev/stripe-android/)。

SDK をインストールするには、[app/build.gradle](https://developer.android.com/studio/build/dependencies) ファイルの `dependencies` ブロックに `stripe-android` を追加します。

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.3.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.3.0")
}
```

> SDK の最新リリースおよび過去バージョンの詳細については、GitHub の [Releases](https://github.com/stripe/stripe-android/releases) ページをご覧ください。新しいリリースの公開時に通知を受け取るには、[リポジトリのリリースを確認](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository)してください。

Stripe の[公開可能キー](https://dashboard.stripe.com/apikeys)を使用して SDK を設定し、 `Application` サブクラスなどで、Stripe API へのリクエストを実行できるようにします。

#### Kotlin

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

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

> テストおよび開発時には[テストキー](https://docs.stripe.com/keys.md#obtain-api-keys)を使用し、アプリの公開時には[本番環境](https://docs.stripe.com/keys.md#test-live-modes)キーを使用します。

Stripe サンプルでは、サーバへの HTTP リクエストの作成に、[OkHttp](https://github.com/square/okhttp) および [GSON](https://github.com/google/gson) も使用します。

## 連結アカウントを作成する
![](https://b.stripecdn.com/docs-statics-srv/assets/express-android.d13776fc7e474c2a0168a705f85b11cb.png)

> 本ガイドでは、特定の[制限](https://docs.stripe.com/connect/express-accounts.md#prerequisites-for-using-express)がある Express アカウントを使用します。代替案として、[Custom アカウント](https://docs.stripe.com/connect/custom-accounts.md)を検討することができます。

### 情報を事前入力して連結アカウントを作成する

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 支払い方法を有効にする

[支払い方法の設定](https://dashboard.stripe.com/settings/connect/payment_methods)を表示し、サポートする支払い方法を有効にします。カード支払い、Google Pay、Apple Pay はデフォルトで有効化されていますが、支払い方法は必要に応じて有効か無効かを設定できます。

決済フォームを表示する前に、Stripe は通貨、決済手段の制約、その他のパラメーターを評価し、対応可能な決済手段のリストを決定します。購入完了率の向上につながり、使用通貨と顧客の所在地に最も適した決済手段が、優先的に表示されます。優先度の低い決済手段は、オーバーフローメニューに隠れた状態になります。

## エンドポイントを追加する [サーバー側]

> #### 注
> 
> PaymentIntent の作成前に PaymentSheet を表示するには、[インテントを作成する前に支払いの詳細を収集する](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment)をご覧ください。

この接続方法では、以下の 3 つの Stripe API オブジェクトを使用します。

1. [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md): Stripe はこれを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して支払いの試行と支払い状態の変化を追跡します。

1. (オプション) [顧客設定アカウント](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) または [Customer](https://docs.stripe.com/api/customers.md) オブジェクト。今後の支払いに備えて決済手段を設定するには、顧客に関連付ける必要があります。顧客がビジネスでアカウントを作成するときに、顧客を表すオブジェクトを作成します。顧客がゲストとして支払いを行う場合は、支払いの前に `Account` または `Customer` オブジェクトを作成し、後で顧客のアカウントを表す独自の内部表現に関連付けることができます。

1. (オプション) [CustomerSession](https://docs.stripe.com/api/customer_sessions.md)。顧客を表すオブジェクトの情報は機密情報であるため、アプリから直接取得することはできません。`CustomerSession` により、SDK に `Account` または `Customer` への範囲を設定した一時的なアクセス権が付与され、追加の設定オプションも提供されます。すべての [設定オプション](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components) のリストをご覧ください。

> 顧客にカードを保存したことがなく、リピート顧客に保存されたカードの再利用を許可しない場合は、導入で `Account` または `Customer` オブジェクトおよび `CustomerSession` オブジェクトを省略できます。

セキュリティ上の理由により、アプリでこれらのオブジェクトを作成することはできません。代わりに、サーバー側で以下を行うエンドポイントを追加します。

1. `Account` または `Customer` を取得するか、新規作成します。
1. `Account` または `Customer` の [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) を作成します。
1. [金額](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount)、[通貨](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency)、および [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) または [customer](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer) を使用して `PaymentIntent` を作成します。
1. `PaymentIntent` の *Client Secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer))、`CustomerSession` の `client_secret`、`Account` または `Customer` の ID、およびアプリの [公開可能キー](https://dashboard.stripe.com/apikeys) を返します。

決済プロセス中に顧客に表示される支払い方法は、PaymentIntent にも含まれています。Stripe にダッシュボードの設定から支払い方法を取得するよう指定することも、手動でリストに表示することもできます。選択したオプションにかかわらず、顧客に表示される支払い方法は、PaymentIntent で渡す通貨によって絞り込まれることにご注意ください。たとえば、PaymentIntent で `eur` を渡し、ダッシュボードで OXXO が有効になっている場合、OXXO は `eur` による決済に対応していないため、顧客に表示されません。

構築済みのシステムで、決済手段を提供するためにコードベースのオプションが必要になる場合を除き、自動化されたオプションを使用することをお勧めします。これは、Stripe が通貨、決済手段の制約、その他のパラメーターを評価して、対応可能な決済手段を決定するためです。自動化されたオプションでは、購入完了率の向上につながり、使用通貨と顧客の所在地に最適な決済手段が優先的に表示されます。

#### ダッシュボードで支払い方法を管理する

支払い方法は[ダッシュボード](https://dashboard.stripe.com/settings/payment_methods)で管理できます。Stripe は取引額、通貨、決済フローなどの要素に基づいて、適切な支払い方法が返されるように処理します。PaymentIntent は、ダッシュボードで設定された支払い方法を使用して作成されます。ダッシュボードを使用しない場合や、支払い方法を手動で指定する場合は、`payment_method_types` 属性を使用して支払い方法を一覧表示することができます。

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### 支払い方法を手動で一覧表示する

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

> 各決済手段は PaymentIntent で渡された通貨に対応している必要があり、ビジネスは、各決済手段を使用できる国のいずれかに所在する必要があります。対応状況について、詳細は[決済手段の導入オプション](https://docs.stripe.com/payments/payment-methods/integration-options.md)ページをご覧ください。

## 決済画面を組み込む [クライアント側]

決済ページでは、Mobile Payment Element を表示する前に以下を実行する必要があります。

- 購入商品と合計金額を表示する
- [Address Element](https://docs.stripe.com/elements/address-element.md?platform=android) を使用して必要な配送先情報を収集する
- Stripe の UI を表示する決済ボタンを含める

#### Jetpack Compose

決済アクティビティーの `onCreate` 内で `PaymentSheet` インスタンスを[初期化](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-builder/index.html)して、結果を処理するメソッドを渡します。

```kotlin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
  // implemented in the next steps
}
```

次に、前のステップで作成したエンドポイントから、PaymentIntent のClient Secret、顧客 SessionのClient Secret、顧客 ID、公開可能キーを取得します。公開可能キーは `PaymentConfiguration` を使用して設定し、その他は保存して、PaymentSheet を表示するときに使用します。

```kotlin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.rememberimport androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()val context = LocalContext.current
  var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
  varpaymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

  LaunchedEffect(context) {
    // Make a request to your own server and retrieve payment configurations
    val networkResult = ...
    if (networkResult.isSuccess) {paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )PaymentConfiguration.init(context, networkResult.publishableKey)}
  }
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
  // implemented in the next steps
}
```

顧客が決済ボタンをタップしたら、[presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) を呼び出して支払い画面を表示します。顧客が決済を完了すると、画面が閉じ、[PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html) とともに [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) が呼び出されます。

```kotlin
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
  val context = LocalContext.current
  var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
  var paymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

  LaunchedEffect(context) {
    // Make a request to your own server and retrieve payment configurations
    val networkResult = ...
    if (networkResult.isSuccess) {
        paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )
        PaymentConfiguration.init(context, networkResult.publishableKey)
    }
  }Button(
    onClick = {
      val currentConfig = customerConfig
      val currentClientSecret =paymentIntentClientSecret

      if (currentConfig != null && currentClientSecret != null) {
        presentPaymentSheet(paymentSheet, currentConfig, currentClientSecret)
      }
    }
  ) {
    Text("Checkout")
  }
}private fun presentPaymentSheet(
  paymentSheet: PaymentSheet,
  customerConfig: PaymentSheet.CustomerConfiguration,paymentIntentClientSecret: String
) {
  paymentSheet.presentWithPaymentIntent(paymentIntentClientSecret,
    PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
      .customer(customerConfig)
      // Set `allowsDelayedPaymentMethods` to true if your business handles
      // delayed notification payment methods like US bank accounts.
      .allowsDelayedPaymentMethods(true)
      .build()
  )
}
private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {when(paymentSheetResult) {
    is PaymentSheetResult.Canceled -> {
      print("Canceled")
    }
    is PaymentSheetResult.Failed -> {
      print("Error: ${paymentSheetResult.error}")
    }
    is PaymentSheetResult.Completed -> {
      // Display for example, an order confirmation screen
      print("Completed")
    }
  }
}
```

#### ビュー (クラシック)

決済アクティビティーの `onCreate` 内で、結果を処理するメソッドを渡して、`PaymentSheet` インスタンスを[初期化](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#-394860221%2FConstructors%2F2002900378)します。

#### Kotlin

```kotlin
import com.stripe.android.paymentsheet.PaymentSheet

class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this)
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
    // implemented in the next steps
  }
}
```

次に、前のステップで作成したエンドポイントから、PaymentIntent のClient Secret、顧客 SessionのClient Secret、顧客 ID、公開可能キーを取得します。公開可能キーは `PaymentConfiguration` を使用して設定し、その他は保存して、PaymentSheet を表示するときに使用します。

#### Kotlin

```kotlin
import com.stripe.android.paymentsheet.PaymentSheet

class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheetlateinit var customerConfig: PaymentSheet.CustomerConfiguration
  lateinit varpaymentIntentClientSecret: String

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this)lifecycleScope.launch {
      // Make a request to your own server and retrieve payment configurations
      val networkResult = MyBackend.getPaymentConfig()
      if (networkResult.isSuccess) {paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )PaymentConfiguration.init(context, networkResult.publishableKey)}
    }
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
    // implemented in the next steps
  }
}
```

顧客が決済ボタンをタップしたら、[presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) を呼び出して支払い画面を表示します。顧客が決済を完了すると、画面が閉じ、[PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html) とともに [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) が呼び出されます。

#### Kotlin

```kotlin
// ...
class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheet
  lateinit var customerConfig: PaymentSheet.CustomerConfiguration
  lateinit var paymentIntentClientSecret: String
  // ...fun presentPaymentSheet() {
    paymentSheet.presentWithPaymentIntent(paymentIntentClientSecret,
      PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
        .customer(customerConfig)
        // Set `allowsDelayedPaymentMethods` to true if your business handles
        // delayed notification payment methods like US bank accounts.
        .allowsDelayedPaymentMethods(true)
        .build()
    )
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {when(paymentSheetResult) {
      is PaymentSheetResult.Canceled -> {
        print("Canceled")
      }
      is PaymentSheetResult.Failed -> {
        print("Error: ${paymentSheetResult.error}")
      }
      is PaymentSheetResult.Completed -> {
        // Display for example, an order confirmation screen
        print("Completed")
      }
    }
  }
}
```

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。

## 支払い後のイベントを処理する [サーバー側]

支払いが完了すると、Stripe は [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) イベントを送信します。[ダッシュボードの Webhook ツール](https://dashboard.stripe.com/webhooks)を使用するか [Webhook のガイド](https://docs.stripe.com/webhooks/quickstart.md)に従ってこれらのイベントを受信し、顧客への注文確認メールの送信、データベースでの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアントでは、コールバックが実行される前に顧客がブラウザーのウィンドウを閉じたり、アプリを終了する場合、また悪意を持つクライアントがレスポンスを不正操作する場合もあります。非同期型のイベントをリッスンするよう組み込みを設定すると、単一の組み込みで[複数の異なるタイプの支払い方法](https://stripe.com/payments/payment-methods-guide)を受け付けることができます。

Payment Element を使用して支払いを回収する場合は、`payment_intent.succeeded` イベントのほかにこれらのイベントを処理することをお勧めします。

| イベント                                                                                                                            | 説明                                                                                                                                                                       | アクション                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded)           | 顧客が正常に支払いを完了したときに送信されます。                                                                                                                                                 | 顧客に注文の確定を送信し、顧客の注文の*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を実行します。 |
| [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing)         | 顧客が正常に支払いを開始したが、支払いがまだ完了していない場合に送信されます。このイベントは、多くの場合、顧客が口座引き落としを開始するときに送信されます。その後、`payment_intent.succeeded` イベント、また、失敗の場合は `payment_intent.payment_failed` イベントが送信されます。 | 顧客に注文確認メールを送信し、支払いが保留中であることを示します。デジタル商品では、支払いの完了を待たずに注文のフルフィルメントを行うことが必要になる場合があります。                                                                                |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | 顧客が支払いを試みたが、支払いに失敗する場合に送信されます。                                                                                                                                           | 支払いが `processing` から `payment_failed` に変わった場合は、顧客に再度支払いを試すように促します。                                                                                                 |

## 構築したシステムをテストする

#### カード

| カード番号               | シナリオ                                                                                                                                                                                                                                                                 | テスト方法                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| 4242424242424242    | カード支払いは成功し、認証は必要とされません。                                                                                                                                                                                                                                              | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000002500003155    | カード支払いには*認証* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase)が必要です。 | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000000000009995    | カードは、`insufficient_funds` などの拒否コードで拒否されます。                                                                                                                                                                                                                           | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 6205500000000000004 | UnionPay カードは、13 ～ 19 桁の可変長です。                                                                                                                                                                                                                                       | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |

#### 銀行へのリダイレクト

| 決済手段             | シナリオ                                                                                                             | テスト方法                                                                                                           |
| ---------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Bancontact、iDEAL | 顧客は、リダイレクトベースの即時通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | リダイレクトベースの任意の支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払い失敗)** をクリックします。           |
| Pay by Bank      | 顧客はリダイレクトベースの、[遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法で支払いに成功します。 | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Complete test payment (テスト支払い完了)** をクリックします。                    |
| Pay by Bank      | 顧客は、リダイレクトベースの遅延通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払いを失敗させる)** をクリックします。                    |
| BLIK             | BLIK による支払いはさまざまな理由で失敗します。即時の失敗 (コードの有効期限切れや無効など)、遅延型のエラー (銀行による拒否など)、またはタイムアウト (顧客が時間内に応答しなかったなど) などがあります。      | メールパターンを使用して[さまざまな失敗をシミュレーションします。](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures) |

#### 口座引き落とし

| 決済手段           | シナリオ                                                                         | テスト方法                                                                                                                   |
| -------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| SEPA ダイレクトデビット | 顧客が SEPA ダイレクトデビットによる支払いに成功しました。                                             | 口座番号 `AT321904300235473204` を使用して、フォームに入力します。確定された PaymentIntent のステータスはまず、processing に移行し、3 分後に succeeded ステータスに移行します。 |
| SEPA ダイレクトデビット | 顧客の Payment Intent のステータスが、`processing` から `requires_payment_method` に移行します。 | 口座番号 `AT861904300235473202` を使用して、フォームに入力します。                                                                           |

実装内容をテストするためのその他の情報については、[テスト](https://docs.stripe.com/testing.md)をご覧ください。

## Optional: Google Pay を有効にする

### 実装方法を設定する

Google Pay を使用するには、まず以下を **AndroidManifest.xml** の `<application>` に追加し、Google Pay API を有効化します。

```xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>
```

詳細は、Google Pay の Android 向け [Google Pay API を設定する](https://developers.google.com/pay/api/android/guides/setup) を参照してください。

### Google Pay を追加する

組み込みに Google Pay を追加するには、[PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-google-pay-configuration/index.html) を初期化する際に、お客様の Google Pay 環境 (本番またはテスト) と[ビジネスの国コード](https://dashboard.stripe.com/settings/account)を指定して [PaymentSheet.GooglePayConfiguration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html) を渡します。

#### Kotlin

```kotlin
val googlePayConfiguration = PaymentSheet.GooglePayConfiguration(
  environment = PaymentSheet.GooglePayConfiguration.Environment.Test,
  countryCode = "US",
  currencyCode = "USD" // Required for Setup Intents, optional for Payment Intents
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
  .googlePay(googlePayConfiguration)
  .build()
```

### Google Pay をテストする

Google では、[テストクレジットカードスイート](https://developers.google.com/pay/api/android/guides/resources/test-card-suite) を使用してテスト決済を行うことができます。Stripe [テストカード](https://docs.stripe.com/testing.md) をテストスイートと併用できます。

Google Pay がサポートされている国では、シミュレーションされたデバイスではなく、物理的な Android デバイスを使用して Google Pay をテストする必要があります。Google ウォレットに保存した実際のクレジットカードを使用して、テスト用デバイスの Google アカウントにログインします。

## Optional: 画面をカスタマイズする

すべてのカスタマイズは、[PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html) オブジェクトを使用して設定されます。

### デザイン

アプリの見た目や使い心地に合わせて、[appearance API](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=android) を使用して色やフォントなどをカスタマイズできます。

### 決済手段のレイアウト

[paymentMethodLayout](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/-builder/index.html#2123253356%2FFunctions%2F2002900378) を使用して、画面上の決済手段のレイアウトを設定します。横や縦に表示することも、Stripe がレイアウトを自動で最適化するように設定することもできます。
![](https://b.stripecdn.com/docs-statics-srv/assets/android-mpe-payment-method-layouts.3bcfe828ceaad1a94e0572a22d91733f.png)

#### Kotlin

```kotlin
PaymentSheet.Configuration.Builder("Example, Inc.")
  .paymentMethodLayout(PaymentSheet.PaymentMethodLayout.Automatic)
  .build()
```

### ユーザーの住所を収集する

[Address Element](https://docs.stripe.com/elements/address-element.md?platform=android) を使用して、顧客から国内および国外の配送先住所や請求先住所を収集します。

### ビジネス表示名

[merchantDisplayName](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html#-191101533%2FProperties%2F2002900378) を設定し、顧客に表示するビジネス名を指定します。デフォルトではアプリ名になります。

#### Kotlin

```kotlin
PaymentSheet.Configuration.Builder(
  merchantDisplayName = "My app, Inc."
).build()
```

### ダークモード

`PaymentSheet` は、ユーザーのシステム全体の表示設定 (ライト/ダークモード) に合わせてデフォルトで自動的に調整されます。これを変更するには、アプリでライトモードまたはダークモードを設定します。

#### Kotlin

```kotlin
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

### デフォルトの請求詳細

支払い画面で収集される請求詳細のデフォルト値を設定するには、`defaultBillingDetails` プロパティーを設定します。`PaymentSheet` の各フィールドに、指定したそれらの値が事前に読み込まれます。

#### Kotlin

```kotlin
val address = PaymentSheet.Address(country = "US")
val billingDetails = PaymentSheet.BillingDetails(
  address = address,
  email = "foo@bar.com"
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .build()
```

### 請求先情報の収集を設定する

`BillingDetailsCollectionConfiguration` を使用して、PaymentSheet で請求詳細を収集する方法を指定します。

顧客の名前、メールアドレス、電話番号、住所を収集できます。

UI でデフォルトの請求詳細が収集されない場合でも、それらの詳細を PaymentMethod オブジェクトに関連付けるには、`billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` を `true` に設定します。

#### Kotlin

```kotlin
val billingDetails = PaymentSheet.BillingDetails(
  email = "foo@bar.com"
)
val billingDetailsCollectionConfiguration = BillingDetailsCollectionConfiguration(
  attachDefaultsToPaymentMethod = true,
  name = BillingDetailsCollectionConfiguration.CollectionMode.Always,
  email = BillingDetailsCollectionConfiguration.CollectionMode.Never,
  address = BillingDetailsCollectionConfiguration.AddressCollectionMode.Full,
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .billingDetailsCollectionConfiguration(billingDetailsCollectionConfiguration)
  .build()
```

> 情報の収集に適用される法律については、弁護士に相談してください。電話番号は、取引に必要な場合にのみ収集してください。

## Optional: UI で支払いを完了する

支払い画面を表示して支払い方法の詳細のみを収集し、アプリの UI に戻って支払いを完了できます。これは、カスタムの購入ボタンがある場合や、支払いの詳細を収集した後で追加のステップが必要な場合に便利です。
![](https://b.stripecdn.com/docs-statics-srv/assets/android-multi-step.84d8a0a44b1baa596bda491322b6d9fd.png)

> 導入サンプルは[GitHubで入手できます](https://github.com/stripe/stripe-android/blob/master/paymentsheet-example/src/main/java/com/stripe/android/paymentsheet/example/samples/ui/paymentsheet/custom_flow/CustomFlowActivity.kt)。

1. 最初に、[Builder](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/-builder/index.html) メソッドのいずれかを使用して、`PaymentSheet` ではなく [PaymentSheet.FlowController](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html) を初期化します。

#### Android (Kotlin)

```kotlin
class CheckoutActivity : AppCompatActivity() {
  private lateinit var flowController: PaymentSheet.FlowController

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val flowController = PaymentSheet.FlowController.Builder(
      resultCallback = ::onPaymentSheetResult,
      paymentOptionResultCallback = ::onPaymentOption,
    ).build(this)
  }
}
```

1. 次に、バックエンドから取得した Stripe オブジェクトキーで `configureWithPaymentIntent` を呼び出し、[getPaymentOption()](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-2091462043%2FFunctions%2F2002900378) を使用してコールバックで UI を更新します。ここには、顧客が現在選択している決済手段を表す画像とラベルが含まれています。

#### Android (Kotlin)

```kotlin
flowController.configureWithPaymentIntent(
  paymentIntentClientSecret = paymentIntentClientSecret,
  configuration = PaymentSheet.Configuration.Builder("Example, Inc.")
    .customer(PaymentSheet.CustomerConfiguration(
      id = customerId,
      ephemeralKeySecret = ephemeralKeySecret
    ))
    .build()
) { isReady, error ->
  if (isReady) {
    // Update your UI using `flowController.getPaymentOption()`
  } else {
    // handle FlowController configuration failure
  }
}
```

1. 次に、[presentPaymentOptions](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#449924733%2FFunctions%2F2002900378) を呼び出して、決済の詳細を収集します。顧客が操作を完了すると、画面は閉じ、すでに `create` で渡されている [paymentOptionCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-option-callback/index.html) が呼び出されます。このメソッドを実装し、返された `paymentOption` で UI を更新します。

#### Android (Kotlin)

```kotlin
// ...
  flowController.presentPaymentOptions()
// ...
  private fun onPaymentOption(paymentOptionResult: PaymentOptionResult) {
    val paymentOption = paymentOptionResult.paymentOption
    if (paymentOption != null) {
      paymentMethodButton.text = paymentOption.label
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        paymentOption.drawableResourceId,
        0,
        0,
        0
      )
    } else {
      paymentMethodButton.text = "Select"
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        null,
        null,
        null,
        null
      )
    }
  }
```

1. 最後に、[confirm](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-479056656%2FFunctions%2F2002900378) を呼び出して支払いを完了します。顧客が操作を完了すると、画面は閉じ、すでに `create` で渡されている [paymentResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html#237248767%2FFunctions%2F2002900378) が呼び出されます。

#### Android (Kotlin)

```kotlin
  // ...
    flowController.confirmPayment()
  // ...

  private fun onPaymentSheetResult(
    paymentSheetResult: PaymentSheetResult
  ) {
    when (paymentSheetResult) {
      is PaymentSheetResult.Canceled -> {
        // Payment canceled
      }
      is PaymentSheetResult.Failed -> {
        // Payment Failed. See logcat for details or inspect paymentSheetResult.error
      }
      is PaymentSheetResult.Completed -> {
        // Payment Complete
      }
    }
  }
```

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。


# カード Element のみ

> This is a カード Element のみ for when platform is android and mobile-ui is card-element. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=android&mobile-ui=card-element.

SDK が提供し、カード番号、有効期限、CVC、郵便番号を収集するドロップイン UI コンポーネントである [CardInputWidget](https://stripe.dev/stripe-android/stripe/com.stripe.android.view/-card-input-widget/index.html) を使用して、クライアント側でカード情報を安全に収集します。
![](https://d37ugbyn3rpeym.cloudfront.net/docs/mobile/android/android-card-input-widget-with-postal.mp4)
このガイドは、決済を受け付け、売上を売り手やサービスプロバイダーの銀行口座に移動する方法をデモンストレーションします。デモンストレーションでは、住宅所有者とレンタル物件を探す人を結びつける住宅賃貸のマーケットプレイスを構築します。このガイドで扱われる概念を他のアプリケーションにも適用することができます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバ側] [クライアント側]

まず、Stripe アカウントが必要です。[今すぐ登録](https://dashboard.stripe.com/register)してください。

### サーバ側

この組み込みには、サーバ上に Stripe API と通信するエンドポイントが必要です。サーバから Stripe API にアクセスするには、Stripe の公式ライブラリを使用します。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### クライアント側

[Stripe Android SDK](https://github.com/stripe/stripe-android) はオープンソースであり、[詳細なドキュメントが提供されています](https://stripe.dev/stripe-android/)。

SDK をインストールするには、[app/build.gradle](https://developer.android.com/studio/build/dependencies) ファイルの `dependencies` ブロックに `stripe-android` を追加します。

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.3.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.3.0")
}
```

> SDK の最新リリースおよび過去バージョンの詳細については、GitHub の [Releases](https://github.com/stripe/stripe-android/releases) ページをご覧ください。新しいリリースの公開時に通知を受け取るには、[リポジトリのリリースを確認](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository)してください。

Stripe の[公開可能キー](https://dashboard.stripe.com/apikeys)を使用して SDK を設定し、 `Application` サブクラスなどで、Stripe API へのリクエストを実行できるようにします。

#### Kotlin

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

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

> テストおよび開発時には[テストキー](https://docs.stripe.com/keys.md#obtain-api-keys)を使用し、アプリの公開時には[本番環境](https://docs.stripe.com/keys.md#test-live-modes)キーを使用します。

Stripe サンプルでは、サーバへの HTTP リクエストの作成に、[OkHttp](https://github.com/square/okhttp) および [GSON](https://github.com/google/gson) も使用します。

## 連結アカウントを作成する

#### Accounts v2

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/v2/core/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

#### Accounts v1

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。
![](https://b.stripecdn.com/docs-statics-srv/assets/express-android.d13776fc7e474c2a0168a705f85b11cb.png)

> 本ガイドでは、特定の[制限](https://docs.stripe.com/connect/express-accounts.md#prerequisites-for-using-express)がある Express アカウントを使用します。代替案として、[Custom アカウント](https://docs.stripe.com/connect/custom-accounts.md)を検討することができます。

### 情報を事前入力して連結アカウントを作成する (サーバー側)

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 決済を受け付ける

### ステップ 3.1: 決済ページを作成する (クライアント側)

SDK が提供し、カード番号、有効期限、セキュリティコード、郵便番号を収集するドロップイン UI コンポーネントである [CardInputWidget](https://stripe.dev/stripe-android/payments-core/com.stripe.android.view/-card-input-widget/index.html) を使用して、クライアント側でカード情報を安全に収集します。
![](https://d37ugbyn3rpeym.cloudfront.net/docs/mobile/android/android-card-input-widget-with-postal.mp4)
以下をチェックアウトページのレイアウトに追加して、カードコンポーネントのインスタンスを作成し、**支払う** ボタンを作成します。

```xml
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="20dp"
    tools:context=".CheckoutActivityKotlin"
    tools:showIn="@layout/activity_checkout">

    <!--  ...  -->

    <com.stripe.android.view.CardInputWidget
        android:id="@+id/cardInputWidget"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:text="@string/pay"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/payButton"
        android:layout_marginTop="20dp"
        android:backgroundTint="@android:color/holo_green_light"/>

    <!--  ...  -->

</LinearLayout>
```

アプリを実行し、決済ページにカードコンポーネントと支払いボタンが表示されることを確認します。

### ステップ 3.2: PaymentIntent を作成する (サーバー側) (クライアント側)

Stripe は [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md) オブジェクトを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して請求の実施と支払い状態の変化を追跡します。

### サーバ側

サーバーで、[amount](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) と [currency](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency) を指定して PaymentIntent を作成するエンドポイントを設定します。支払い金額は、クライアント側ではなく、常に信頼できる環境のサーバー側で指定してください。これにより、悪意のある顧客が金額を恣意的に選択できないようにします。

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d amount=1000 \
  -d currency="usd" \
  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_STRIPE_ACCOUNT_ID}}"
```

住宅賃貸の例では、顧客が Stripe プラットフォームを使用して賃借料を支払い、Stripe が顧客の賃貸料を住宅所有者に支払うビジネスを構築します。このビジネスを設定するには、次の手順に従います。

- `transfer_data[destination]` で、賃借料がデスティネーション支払いであることを示す。
- `application_fee_amount` で、賃借料の内、プラットフォームに送られる金額を指定する。

賃借料の支払いが行われたら、Stripe は連結アカウントの保留中の残高 (`transfer_data[destination]`) に全額送金します。その後、Stripe は手数料の金額 (`application_fee_amount`) をプラットフォームのアカウントに送金します。これは賃貸事業を支えるレベニューシェアです。その後、Stripe はプラットフォームの手数料の金額から Stripe 手数料を差し引きます。この資金フローを以下の図で示しています。
![](https://b.stripecdn.com/docs-statics-srv/assets/application_fee_amount.837aa2339469b3c1a4319672971c1367.svg)

> この PaymentIntent は、デスティネーション支払いを作成します。送金のタイミングを管理したり、1 回の支払いの売上を複数の当事者に送金したりする必要がある場合は、代わりに[支払いと送金別方式](https://docs.stripe.com/connect/separate-charges-and-transfers.md)を使用してください。

アプリケーションに PaymentIntent オブジェクト全体を渡す代わりに、*client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) のみを返してください。PaymentIntent のクライアントシークレットは、支払いを確認したりクライアント上でカード情報を更新したりするための固有キーであり、支払金額などの機密情報を操作されることを防ぎます。

### クライアント側

クライアント側で、サーバーの PaymentIntent をリクエストし、その *client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) を保存します。

#### Kotlin

```kotlin
class CheckoutActivity : AppCompatActivity() {

  private lateinit var paymentIntentClientSecret: String

  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      // ...
      startCheckout()
  }

  private fun startCheckout() {
      // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret
      // Click View full sample to see a complete implementation
  }
}
```

### ステップ 3.3: Stripe に支払いを送金する (クライアント側)

顧客が**支払い**ボタンをタップしたら、支払いを完了するために `PaymentIntent` を*確定* (Confirming a PaymentIntent indicates that the customer intends to pay with the current or provided payment method. Upon confirmation, the PaymentIntent attempts to initiate a payment)します。

まず、以下を使用して [ConfirmPaymentIntentParams](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-confirm-payment-intent-params/index.html) オブジェクトを作成します。

1. カードコンポーネントの支払い方法詳細
1. サーバから取得した `PaymentIntent` client secret

PaymentIntent オブジェクト全体をクライアントに送信するのではなく、その *client secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) を使用します。これは、Stripe API リクエストを認証する API キーとは異なります。client secret は、アプリで機密情報を含むフィールド (`customer` など) を非表示にしながら、PaymentIntent の重要なフィールド (`status` など) にアクセスできるようにする文字列です。

client secret は支払いを完了できるため、慎重に取り扱う必要があります。記録したり、URL に埋め込んだり、当該の顧客以外に漏洩することがないようにしてください。

次に、[PaymentLauncher confirm](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690) メソッドを呼び出して、支払いを完了します。

#### Kotlin

```kotlin
class CheckoutActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private lateinit var paymentLauncher: PaymentLauncher

    private fun startCheckout() {
        // ...

        // Hook up the pay button to the card widget and stripe instance
        val payButton: Button = findViewById(R.id.payButton)
        payButton.setOnClickListener {
            val params = cardInputWidget.paymentMethodCreateParams
            if (params != null) {
                val confirmParams = ConfirmPaymentIntentParams
                    .createWithPaymentMethodCreateParams(params, paymentIntentClientSecret)
                val paymentConfiguration = PaymentConfiguration.getInstance(applicationContext)
                paymentLauncher = PaymentLauncher.Companion.create(
                    this,
                    paymentConfiguration.publishableKey,
                    paymentConfiguration.stripeAccountId,
                    ::onPaymentResult
                )
                paymentLauncher.confirm(confirmParams)
            }
        }
    }

    private fun onPaymentResult(paymentResult: PaymentResult) {
        val message = when (paymentResult) {
            is PaymentResult.Completed -> {
                "Completed!"
            }
            is PaymentResult.Canceled -> {
                "Canceled!"
            }
            is PaymentResult.Failed -> {
                // This string comes from the PaymentIntent's error message.
                // See here: https://stripe.com/docs/api/payment_intents/object#payment_intent_object-last_payment_error-message
                "Failed: " + paymentResult.throwable.message
            }
        }
        displayAlert(
            "PaymentResult: ",
            message,
            restartDemo = true
        )
    }
}
```

`PaymentIntent` に `setupFutureUsage` と `customer` の両方を指定することで、支払い確定時に[顧客の支払いカードの詳細を保存](https://docs.stripe.com/payments/payment-intents.md#future-usage)できます。サーバーで `PaymentIntent` を作成する際にも、これらのパラメーターを指定できます。

アプリケーションに適した `setupFutureUsage` 値を設定するには、顧客による追加の認証ステップが必要になる場合がありますが、今後支払いが銀行によって拒否される確率を減らすことができます。[今後の支払いのためにカードを最適化する方法を確認](https://docs.stripe.com/payments/payment-intents.md#future-usage)し、アプリケーションに使用する値を決定します。

| 予定しているカードの使用方法                                                                                                                                                      | `setup_future_usage` 列挙値 |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| *オンセッション* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method)支払いのみ | `on_session`             |
| *オフセッション* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method)支払いのみ | `off_session`            |
| オンセッション支払いとオフセッション支払いの両方                                                                                                                                            | `off_session`            |

オンセッション支払い用に設定されたカードをオフセッション支払いに使用することもできますが、銀行がオフセッション支払いを拒否し、カード保有者に認証を求める可能性が高くなります。

[強力な顧客認証 (SCA)](https://docs.stripe.com/strong-customer-authentication.md) などの規制によって認証が要求される場合、SDK は追加のアクティビティーを表示し、そのプロセスをステップごとに顧客に提示します。[Android で 3D セキュア認証に対応する方法を確認してください](https://docs.stripe.com/payments/3d-secure.md?platform=android)。

支払いが完了すると `onSuccess` がコールされ、返される `PaymentIntent` の `status` の値は `Succeeded` となります。他の値はいずれも、支払いが成功しなかったことを示します。[lastPaymentError](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-payment-intent/index.html#com.stripe.android.model/PaymentIntent/lastPaymentError/#/PointingToDeclaration/) を調べて原因を特定します。

`PaymentIntent` のステータスは、[ダッシュボード](https://dashboard.stripe.com/test/payments)で確認できるほか、オブジェクトの `status` プロパティを調べることでも確認できます。

### ステップ 3.4: 実装内容をテストする (クライアント側)

​​この実装の準備ができていることを確認するために、サンドボックスで使用できるテストカードがいくつかあります。任意のセキュリティコードおよび将来の有効期限を指定して使用します。

| 番号               | 説明                                      |
| ---------------- | --------------------------------------- |
| 4242424242424242 | 支払いが成功し、すぐに処理されます。                      |
| 4000002500003155 | 認証が必要です。Stripe は、顧客に認証を求めるモーダルをトリガーします。 |
| 4000000000009995 | 常に支払い拒否コード `insufficient_funds` で失敗します。 |

テストカードの一覧については、[テスト](https://docs.stripe.com/testing.md)に関するガイドを参照してください。

### ステップ 3.5: フルフィルメントを実行する (サーバー側)

支払いの完了後、お客様側で必要な*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を処理する必要があります。たとえば、前払いを必要とする住宅賃貸会社は、支払いが成功した後に、住宅所有者と賃借人を関連付けます。

[ダッシュボード](https://dashboard.stripe.com/account/webhooks)で (「お客様のアカウントから」イベント用に) *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) エンドポイントを構成します。
![](https://b.stripecdn.com/docs-statics-srv/assets/account_webhooks.03b71cec87ef2093fe0caa92e5bfce44.png)

次に、お客様のサーバ上に HTTP エンドポイントを作成し、完了した支払いを監視し、売り手またはサービスプロバイダが購入内容をフルフィルメントできるようにします。サンプルのエンドポイントシークレットキー (`whsec_...`) は、必ず各自のキーに置き換えてください。

#### Ruby

```ruby
# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
# Find your keys at https://dashboard.stripe.com/apikeys.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

# If you are testing your webhook locally with the Stripe CLI you
# can find the endpoint's secret by running `stripe listen`
# Otherwise, find your endpoint's secret in your webhook settings in
# the Developer Dashboard
endpoint_secret = 'whsec_...'

post '/webhook' do
  payload = request.body.read
  sig_header = request.env['HTTP_STRIPE_SIGNATURE']

  event = nil
# Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks#verify-events for more information.
  begin
    event = Stripe::Webhook.construct_event(
      payload, sig_header, endpoint_secret
    )
  rescue JSON::ParserError => e
    # Invalid payload.
    status 400
    return
  rescue Stripe::SignatureVerificationError => e
    # Invalid Signature.
    status 400
    return
  end

  if event['type'] == 'payment_intent.succeeded'
    payment_intent = event['data']['object']
    handle_successful_payment_intent(payment_intent)
  end

  status 200
end

def handle_successful_payment_intent(payment_intent)
  # Fulfill the purchase
  puts payment_intent.to_s
end
```

[決済向けフルフィルメントガイド](https://docs.stripe.com/webhooks/handling-payment-events.md)で詳細をご確認ください。

### Webhook をローカルでテストする

Stripe CLI を使用すると、Webhook をローカルでテストできます。

1. まず、[Stripe CLI をインストール](https://docs.stripe.com/stripe-cli/install.md)していない場合は、マシンにインストールしてください。

1. 次に、ログインするために、コマンドラインで `stripe login` を実行し、手順に従います。

1. 最後に、連結アカウントでシミュレートされたイベントをローカルホストで受信できるようにするために、1 つの端末ウィンドウで `stripe listen --forward-to localhost:{PORT}/webhook` を実行し、別の端末ウィンドウで `stripe trigger --stripe-account={{CONNECTED_STRIPE_ACCOUNT_ID}} payment_intent.succeeded` を実行します (あるいはその他の[サポートされているイベント](https://github.com/stripe/stripe-cli/wiki/trigger-command#supported-events)をトリガーします) 。

### ステップ 3.6: 不審請求の申請

お客様は支払いの[売上処理加盟店](https://docs.stripe.com/connect/destination-charges.md#settlement-merchant)であるため、お客様のプラットフォームは不審請求の申請に対する責任を負います。不審請求の申請に対応するための[ベストプラクティス](https://docs.stripe.com/disputes/responding.md)を必ず理解するようにしてください。

## テスト

[アカウントを作成](https://docs.stripe.com/connect/testing.md#creating-accounts)し、[OAuth を使用](https://docs.stripe.com/connect/testing.md#using-oauth)して、アカウント作成フローをテストします。[利用可能なテストカード](https://docs.stripe.com/testing.md)を使用して、支払いフローをテストし、さまざまな支払い結果をシミュレーションできます。


# React Native

> This is a React Native for when platform is react-native and mobile-ui is payment-element. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=react-native&mobile-ui=payment-element.
![](https://b.stripecdn.com/docs-statics-srv/assets/ios-overview.9e0d68d009dc005f73a6f5df69e00458.png)

この統合は、決済の詳細収集や決済確認など、決済に必要なすべてのステップを一つのシートにまとめ、アプリ上部に表示されます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィールを完成](https://dashboard.stripe.com/connect/settings/profile)させます。
1. [ブランド設定をカスタマイズ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)します。ビジネス名、アイコン、ブランドカラーを追加します。

## Stripe を設定する [サーバー側] [クライアント側]

まず、Stripe アカウントが必要です。[今すぐご登録ください](https://dashboard.stripe.com/register)。

### サーバー側

この接続方法では、Stripe API と通信するエンドポイントがサーバー上に必要です。サーバーから Stripe API にアクセスするには、Stripe の公式ライブラリを使用します。

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### クライアント側

[React Native SDK](https://github.com/stripe/stripe-react-native) はオープンソースであり、詳細なドキュメントが提供されています。内部では、[ネイティブの iOS](https://github.com/stripe/stripe-ios) および [Android](https://github.com/stripe/stripe-android) の SDK を使用します。Stripe の React Native SDK をインストールするには、プロジェクトのディレクトリーで (使用するパッケージマネージャーによって異なる) 次のいずれかのコマンドを実行します。

#### yarn

```bash
yarn add @stripe/stripe-react-native
```

#### npm

```bash
npm install @stripe/stripe-react-native
```

次に、その他の必要な依存関係をインストールします。

- iOS の場合は、**ios** ディレクトリに移動して `pod install` を実行し、必要なネイティブ依存関係もインストールします。
- Android の場合は、依存関係をインストールする必要はありません。

> [公式の TypeScript ガイド](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project)に従って TypeScript のサポートを追加することをお勧めします。

### Stripe の初期化

React Native アプリで Stripe を初期化するには、決済画面を `StripeProvider` コンポーネントでラップするか、`initStripe` 初期化メソッドを使用します。`publishableKey` の API [公開可能キー](https://docs.stripe.com/keys.md#obtain-api-keys)のみが必要です。次の例は、`StripeProvider` コンポーネントを使用して Stripe を初期化する方法を示しています。

```jsx
import { useState, useEffect } from 'react';
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  const [publishableKey, setPublishableKey] = useState('');

  const fetchPublishableKey = async () => {
    const key = await fetchKey(); // fetch key from your server here
    setPublishableKey(key);
  };

  useEffect(() => {
    fetchPublishableKey();
  }, []);

  return (
    <StripeProvider
      publishableKey={publishableKey}
      merchantIdentifier="merchant.identifier" // required for Apple Pay
      urlScheme="your-url-scheme" // required for 3D Secure and bank redirects
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

> テストおよび開発時には API の[テストキー](https://docs.stripe.com/keys.md#obtain-api-keys)を使用し、アプリの公開時には[本番環境](https://docs.stripe.com/keys.md#test-live-modes)キーを使用します。

## 連結アカウントを作成する

#### Accounts v2

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/v2/core/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

#### Accounts v1

売り手または代行業者がプラットフォームに登録したら、それらを表す [連結アカウント](https://docs.stripe.com/api/accounts.md) を作成します。連結アカウントを使用すると売り手の識別情報を収集し、売り手の決済を受け付け、売上を売り手の銀行口座に移動できます。住宅賃貸の例では、連結アカウントは住宅所有者を表します。

### 情報を事前入力して連結アカウントを作成する

#### Accounts v2

`/v2/core/accounts` API を使用して、[連結アカウントのダッシュボードと責任](https://docs.stripe.com/connect/accounts-v2/connected-account-configuration.md)を指定して連結アカウントを[作成](https://docs.stripe.com/api/v2/core/accounts/create.md)します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-01-28.clover" \
  --json '{
    "contact_email": "furever_contact@example.com",
    "display_name": "Furever",
    "defaults": {
        "responsibilities": {
            "fees_collector": "application",
            "losses_collector": "application"
        }
    },
    "dashboard": "express",
    "identity": {
        "business_details": {
            "registered_name": "Furever"
        },
        "country": "us",
        "entity_type": "company"
    },
    "configuration": {
        "merchant": {
            "capabilities": {
                "card_payments": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "stripe_balance": {
                    "stripe_transfers": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.merchant",
        "configuration.recipient",
        "identity",
        "requirements"
    ]
  }'
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、[Person](https://docs.stripe.com/api/v2/core/persons/create.md) を作成してアカウント開設の責任者を表します。この際、`relationship.representative` を true に設定し、事前に入力したいアカウント情報 (氏名など) を指定します。

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{ACCOUNT_ID}}/persons \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "given_name": "Jenny",
    "surname": "Rosen",
    "email": "jenny.rosen@example.com",
    "relationship": {
        "representative": true
    }
  }'
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`
- `configurations` = `recipient` と `merchant`

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2025-08-27.preview" \
  --json '{
    "account": "{{CONNECTEDACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient",
                "merchant"
            ],
            "refresh_url": "https://example.com/reauth",
            "return_url": "https://example.com/return"
        }
    }
  }'
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証したら、この URL にリダイレクトしてフローに送ります。アカウントリンク URL は連結アカウントユーザーの個人情報へのアクセスを許可するため、一時的な 1 回限りの使用です。情報を事前入力する場合は、アカウントリンクを生成する前に入力する必要があります。アカウントリンクの作成後は連結アカウントの情報の読み取りまたは書き込みができなくなります。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

#### Item 3

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では `return_url` と `refresh_url` の両方を渡して、アカウントユーザーがプラットフォームにリダイレクトされるすべてのケースを処理する必要があります。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

この URL を通じて状態は渡されません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行いアカウントの要件の状態を確認します。

- `v2.core.account[requirements].updated` Webhook をリッスンします。
- [Accounts v2](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) API を呼び出し、返されたオブジェクトを検査します。

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v2](https://docs.stripe.com/api/v2/core/account-links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーがアカウント登録プロセスを完了していない可能性があります。`/v2/core/accounts` エンドポイントを使用してユーザーのアカウントを取得し、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status) が `active` かどうかを確認します。ステータスが `active` ではなく、[configuration.recipient.capabilities.stripe_balance.stripe_transfers.status_details.code](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-recipient-capabilities-stripe_balance-stripe_transfers-status_details-code) が `requirements_past_due` の場合は、UI プロンプトを表示してユーザーが新しいアカウントリンクを使用してアカウント登録を続行できるようにします。必要に応じて他のコードも処理します。

#### Accounts v1

`/v1/accounts` API を使用して連結アカウントを[作成](https://docs.stripe.com/api/accounts/create.md)するには、[連結アカウントのプロパティ](https://docs.stripe.com/connect/migrate-to-controller-properties.md)を指定するか、アカウントタイプを指定します。

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[losses][payments]=application" \
  -d "controller[fees][payer]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

連結アカウントの情報をすでに収集している場合は、`Account` オブジェクトにその情報を事前入力できます。個人情報や事業情報、外部のアカウント情報など、あらゆるアカウント情報を事前に入力できます。

`Account` を作成したら、`relationship.representative` を true に設定した [Person](https://docs.stripe.com/api/persons/create.md) を作成して、アカウント開設の責任者と、事前に入力したいアカウント情報 (氏名など) を表します。

```curl
curl https://api.stripe.com/v1/accounts/{{ACCOUNT_ID}}/persons \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d first_name=Jenny \
  -d last_name=Rosen \
  -d "relationship[representative]=true"
```

Connect アカウント登録で、事前入力された情報が要求されることはありません。ただし、アカウント所有者は [Connect 利用規約](https://docs.stripe.com/connect/service-agreement-types.md)に同意する前に、事前入力された情報を確認するよう求められます。

実装内容をテストする場合、[テストデータ](https://docs.stripe.com/connect/testing.md)を使用してアカウント情報を事前入力します。

### アカウントリンクを作成する

以下のパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) API を呼び出すことでアカウントリンクを作成できます。

- `account`
- `refresh_url`
- `return_url`
- `type` = `account_onboarding`

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/reauth" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding
```

### ユーザーをアカウントリンク URL にリダイレクトする

アカウントリンク作成レスポンスには `url` 値が含まれます。アプリケーションでユーザーを認証した後、この URL にリダイレクトしてフローに送ります。[Account Links v1](https://docs.stripe.com/api/account_links.md) API のアカウントリンク URL は一時的なもので、連結アカウントユーザーの個人情報へのアクセスを許可するため 1 回限りの使用です。この URL にリダイレクトする前にアプリケーションでユーザーを認証します。情報を事前入力する場合は、アカウントリンクを生成する前に行う必要があります。アカウントリンクを作成した後は連結アカウントの情報を読み書きできません。

> アカウントリンクの URL をメールやショートメッセージ、またはその他の方法で、プラットフォームのアプリケーション外に送信しないでください。URL は、アプリケーション内で認証済みのアカウント所有者に提供してください。

#### Item 1

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Item 2

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

### プラットフォームに戻るユーザーを処理する

Connect アカウント登録では、ユーザーがプラットフォームにリダイレクトされるすべてのケースを処理するために `return_url` と `refresh_url` の両方を渡す必要があります。ユーザーが快適に操作できるようにするにはこれらを正しく実装することが重要です。

> テスト環境 (たとえば localhost でテストする場合) では、`return_url` と `refresh_url` に HTTP を使用できますが、本番環境で使用できるのは HTTPS のみです。本番環境へ移行する前に、テスト用 URL を HTTPS URL に更新する必要があります。

#### return_url

連結アカウントユーザーがアカウント登録フローを完了すると、Stripe はこの URL へのリダイレクトを実行します。ただしこれはすべての情報が収集されたことを意味するものでも、アカウントの要件がすべて満たされたことを意味するものでもありません。ユーザーがフローに正常に入りそこから正常に出たことのみを意味します。

パラメーターの状態がこの URL を通じて渡されることはありません。ユーザーが `return_url` にリダイレクトされたら、以下のいずれかを行い、アカウントの `details_submitted` パラメーターの状態を確認します。

- `account.updated` Webhook をリッスンする
- [Accounts v1](https://docs.stripe.com/api/accounts.md) API を呼び出して、返されたオブジェクトを調べる

#### refresh_url

以下のケースでは、Stripe はユーザーを `refresh_url` にリダイレクトします。

- リンクの期限が切れている (リンク作成後、数分が経過した)。
- ユーザーがすでに URL にアクセスしている (ユーザーがページを更新したか、ブラウザーで戻るボタンまたは進むボタンをクリックした)。
- プラットフォームがアカウントにアクセスできなくなった。
- アカウントが拒否された。

サーバーで同じパラメーターを使用して [Account Links v1](https://docs.stripe.com/api/account_links.md) を再度呼び出すメソッドをトリガーし、ユーザーを新しいリンクにリダイレクトするように `refresh_url` ページを設定します。

### アカウント登録を完了していないユーザーを処理する

`return_url` にリダイレクトされたユーザーは、ユーザー登録プロセスを完了していないことがあります。`/v1/accounts` エンドポイントを使用してユーザーのアカウントを取得し `charges_enabled` を確認します。アカウントのユーザー登録が完全でない場合は UI プロンプトを表示し、ユーザーが新しいアカウントリンクでユーザー登録を続行できるようにします。アカウントの `details_submitted` パラメーターの状態を調べると、ユーザー登録を完了したかどうかを確認できます。

## 支払い方法を有効にする

[支払い方法の設定](https://dashboard.stripe.com/settings/connect/payment_methods)を表示し、サポートする支払い方法を有効にします。カード支払い、Google Pay、Apple Pay はデフォルトで有効化されていますが、支払い方法は必要に応じて有効か無効かを設定できます。

決済フォームを表示する前に、Stripe は通貨、決済手段の制約、その他のパラメーターを評価し、対応可能な決済手段のリストを決定します。購入完了率の向上につながり、使用通貨と顧客の所在地に最も適した決済手段が、優先的に表示されます。優先度の低い決済手段は、オーバーフローメニューに隠れた状態になります。

## エンドポイントを追加する [サーバー側]

> #### 注
> 
> PaymentIntent の作成前に PaymentSheet を表示するには、[インテントを作成する前に支払いの詳細を収集する](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment)をご覧ください。

この接続方法では、以下の 3 つの Stripe API オブジェクトを使用します。

1. [PaymentIntent (支払いインテント)](https://docs.stripe.com/api/payment_intents.md): Stripe はこれを使用して、顧客から支払いを回収する意図を示し、プロセス全体を通して支払いの試行と支払い状態の変化を追跡します。

1. (オプション) [顧客設定アカウント](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) または [Customer](https://docs.stripe.com/api/customers.md) オブジェクト。今後の支払いに備えて決済手段を設定するには、顧客に関連付ける必要があります。顧客がビジネスでアカウントを作成するときに、顧客を表すオブジェクトを作成します。顧客がゲストとして支払いを行う場合は、支払いの前に `Account` または `Customer` オブジェクトを作成し、後で顧客のアカウントを表す独自の内部表現に関連付けることができます。

1. (オプション) [CustomerSession](https://docs.stripe.com/api/customer_sessions.md)。顧客を表すオブジェクトの情報は機密情報であるため、アプリから直接取得することはできません。`CustomerSession` により、SDK に `Account` または `Customer` への範囲を設定した一時的なアクセス権が付与され、追加の設定オプションも提供されます。すべての [設定オプション](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components) のリストをご覧ください。

> 顧客にカードを保存したことがなく、リピート顧客に保存されたカードの再利用を許可しない場合は、導入で `Account` または `Customer` オブジェクトおよび `CustomerSession` オブジェクトを省略できます。

セキュリティ上の理由により、アプリでこれらのオブジェクトを作成することはできません。代わりに、サーバー側で以下を行うエンドポイントを追加します。

1. `Account` または `Customer` を取得するか、新規作成します。
1. `Account` または `Customer` の [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) を作成します。
1. [金額](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount)、[通貨](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency)、および [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) または [customer](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer) を使用して `PaymentIntent` を作成します。
1. `PaymentIntent` の *Client Secret* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer))、`CustomerSession` の `client_secret`、`Account` または `Customer` の ID、およびアプリの [公開可能キー](https://dashboard.stripe.com/apikeys) を返します。

決済プロセス中に顧客に表示される支払い方法は、PaymentIntent にも含まれています。Stripe にダッシュボードの設定から支払い方法を取得するよう指定することも、手動でリストに表示することもできます。選択したオプションにかかわらず、顧客に表示される支払い方法は、PaymentIntent で渡す通貨によって絞り込まれることにご注意ください。たとえば、PaymentIntent で `eur` を渡し、ダッシュボードで OXXO が有効になっている場合、OXXO は `eur` による決済に対応していないため、顧客に表示されません。

構築済みのシステムで、決済手段を提供するためにコードベースのオプションが必要になる場合を除き、自動化されたオプションを使用することをお勧めします。これは、Stripe が通貨、決済手段の制約、その他のパラメーターを評価して、対応可能な決済手段を決定するためです。自動化されたオプションでは、購入完了率の向上につながり、使用通貨と顧客の所在地に最適な決済手段が優先的に表示されます。

#### ダッシュボードで支払い方法を管理する

支払い方法は[ダッシュボード](https://dashboard.stripe.com/settings/payment_methods)で管理できます。Stripe は取引額、通貨、決済フローなどの要素に基づいて、適切な支払い方法が返されるように処理します。PaymentIntent は、ダッシュボードで設定された支払い方法を使用して作成されます。ダッシュボードを使用しない場合や、支払い方法を手動で指定する場合は、`payment_method_types` 属性を使用して支払い方法を一覧表示することができます。

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### 支払い方法を手動で一覧表示する

#### Accounts v2

#### curl

```bash
# Create an Account with the customer configuration (use an existing Account ID if this is a returning customer)
curl https://api.stripe.com/v2/core/accounts \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "configuration[customer]"

# Create a CustomerSession for the Account
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Customers v1

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_types[]"="bancontact" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="ideal" \
  -d "payment_method_types[]"="klarna" \
  -d "payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

> 各決済手段は PaymentIntent で渡された通貨に対応している必要があり、ビジネスは、各決済手段を使用できる国のいずれかに所在する必要があります。対応状況について、詳細は[決済手段の導入オプション](https://docs.stripe.com/payments/payment-methods/integration-options.md)ページをご覧ください。

## 決済画面を組み込む [クライアント側]

決済ページでは、モバイル決済 Element を表示する前に以下を実行する必要があります。

- 購入商品と合計金額を表示する
- 必要な配送先情報を収集する
- Stripe の UI を表示する決済ボタンを含める

アプリの決済フローで、前のステップで作成したバックエンドのエンドポイントにネットワークリクエストを送信し、`useStripe` フックから `initPaymentSheet` を呼び出します。

#### Accounts v2

```javascript
export default function CheckoutScreen() {
  const { initPaymentSheet, presentPaymentSheet } = useStripe();
  const [loading, setLoading] = useState(false);

  const fetchPaymentSheetParams = async () => {
    const response = await fetch(`${API_URL}/payment-sheet`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
    });
    const { paymentIntent, ephemeralKey, customer_account } = await response.json();

    return {
      paymentIntent,
      ephemeralKey,
      customer_account,
    };
  };

  const initializePaymentSheet = async () => {
    const {
      paymentIntent,
      ephemeralKey,
      customer_account,
    } = await fetchPaymentSheetParams();

    const { error } = await initPaymentSheet({
      merchantDisplayName: "Example, Inc.",
      customerAccountId: customer_account,
      customerEphemeralKeySecret: ephemeralKey,
      paymentIntentClientSecret: paymentIntent,
      // Set `allowsDelayedPaymentMethods` to true if your business accepts payment
      // methods that complete payment after a delay, like SEPA Debit and Sofort.
      allowsDelayedPaymentMethods: true,
      defaultBillingDetails: {
        name: 'Jane Doe',
      }
    });
    if (!error) {
      setLoading(true);
    }
  };

  const openPaymentSheet = async () => {
    // see below
  };

  useEffect(() => {
    initializePaymentSheet();
  }, []);

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

#### Customers v1

```javascript

export default function CheckoutScreen() {
  const { initPaymentSheet, presentPaymentSheet } = useStripe();
  const [loading, setLoading] = useState(false);

  const fetchPaymentSheetParams = async () => {
    const response = await fetch(`${API_URL}/payment-sheet`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
    });
    const { paymentIntent, ephemeralKey, customer } = await response.json();

    return {
      paymentIntent,
      ephemeralKey,
      customer,
    };
  };

  const initializePaymentSheet = async () => {
    const {
      paymentIntent,
      ephemeralKey,
      customer,
    } = await fetchPaymentSheetParams();

    const { error } = await initPaymentSheet({
      merchantDisplayName: "Example, Inc.",
      customerId: customer,
      customerEphemeralKeySecret: ephemeralKey,
      paymentIntentClientSecret: paymentIntent,
      // Set `allowsDelayedPaymentMethods` to true if your business can handle payment
      //methods that complete payment after a delay, like SEPA Debit and Sofort.
      allowsDelayedPaymentMethods: true,
      defaultBillingDetails: {
        name: 'Jane Doe',
      }
    });
    if (!error) {
      setLoading(true);
    }
  };

  const openPaymentSheet = async () => {
    // see below
  };

  useEffect(() => {
    initializePaymentSheet();
  }, []);

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

顧客が**決済**ボタンをタップしたら、`presentPaymentSheet()` を呼び出して画面を表示します。顧客が支払いを完了すると、この画面は閉じ、オプションの `StripeError<PaymentSheetError>` とともに promise が解決されます。

```javascript
export default function CheckoutScreen() {
  // continued from above

  const openPaymentSheet = async () => {
    const { error } = await presentPaymentSheet();

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else {
      Alert.alert('Success', 'Your order is confirmed!');
    }
  };

  return (
    <Screen>
      <Button
        variant="primary"
        disabled={!loading}
        title="Checkout"
        onPress={openPaymentSheet}
      />
    </Screen>
  );
}
```

エラーがない場合は、ユーザーに完了したことを伝えます (注文確認画面を表示するなど)。

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。

## 戻り先 URL を設定する (iOS のみ) [クライアント側]

顧客はお客様のアプリから離れて、(Safari やバンキングアプリなどで) 認証する場合があります。ユーザーが認証後にアプリに自動的に戻れるようにするには、[カスタム URL スキームを構成](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app)し、URL を SDK に転送するようにアプリのデリゲートを設定します。Stripe は[ユニバーサルリンク](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content)には対応していません。

#### SceneDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else {
        return
    }
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (!stripeHandled) {
        // This was not a Stripe url – handle the URL normally as you would
    }
}

```

#### AppDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (stripeHandled) {
        return true
    } else {
        // This was not a Stripe url – handle the URL normally as you would
    }
    return false
}
```

#### SwiftUI

#### Swift

```swift

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      Text("Hello, world!").onOpenURL { incomingURL in
          let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL)
          if (!stripeHandled) {
            // This was not a Stripe url – handle the URL normally as you would
          }
        }
    }
  }
}
```

さらに、[PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html) オブジェクトの [returnURL](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV9returnURLSSSgvp) をアプリの URL に設定します。

```swift
var configuration = PaymentSheet.Configuration()
configuration.returnURL = "your-app://stripe-redirect"
```

## 支払い後のイベントを処理する

支払いが完了すると、Stripe は [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) イベントを送信します。[ダッシュボードの Webhook ツール](https://dashboard.stripe.com/webhooks)を使用するか [Webhook のガイド](https://docs.stripe.com/webhooks/quickstart.md)に従ってこれらのイベントを受信し、顧客への注文確認メールの送信、データベースでの売上の記録、配送ワークフローの開始などのアクションを実行します。

クライアントからのコールバックを待つのではなく、これらのイベントをリッスンします。クライアントでは、コールバックが実行される前に顧客がブラウザーのウィンドウを閉じたり、アプリを終了する場合、また悪意を持つクライアントがレスポンスを不正操作する場合もあります。非同期型のイベントをリッスンするよう組み込みを設定すると、単一の組み込みで[複数の異なるタイプの支払い方法](https://stripe.com/payments/payment-methods-guide)を受け付けることができます。

Payment Element を使用して支払いを回収する場合は、`payment_intent.succeeded` イベントのほかにこれらのイベントを処理することをお勧めします。

| イベント                                                                                                                            | 説明                                                                                                                                                                       | アクション                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded)           | 顧客が正常に支払いを完了したときに送信されます。                                                                                                                                                 | 顧客に注文の確定を送信し、顧客の注文の*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を実行します。 |
| [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing)         | 顧客が正常に支払いを開始したが、支払いがまだ完了していない場合に送信されます。このイベントは、多くの場合、顧客が口座引き落としを開始するときに送信されます。その後、`payment_intent.succeeded` イベント、また、失敗の場合は `payment_intent.payment_failed` イベントが送信されます。 | 顧客に注文確認メールを送信し、支払いが保留中であることを示します。デジタル商品では、支払いの完了を待たずに注文のフルフィルメントを行うことが必要になる場合があります。                                                                                |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | 顧客が支払いを試みたが、支払いに失敗する場合に送信されます。                                                                                                                                           | 支払いが `processing` から `payment_failed` に変わった場合は、顧客に再度支払いを試すように促します。                                                                                                 |

## 構築したシステムをテストする

#### カード

| カード番号               | シナリオ                                                                                                                                                                                                                                                                 | テスト方法                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| 4242424242424242    | カード支払いは成功し、認証は必要とされません。                                                                                                                                                                                                                                              | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000002500003155    | カード支払いには*認証* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase)が必要です。 | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 4000000000009995    | カードは、`insufficient_funds` などの拒否コードで拒否されます。                                                                                                                                                                                                                           | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |
| 6205500000000000004 | UnionPay カードは、13 ～ 19 桁の可変長です。                                                                                                                                                                                                                                       | クレジットカード番号と、任意の有効期限、セキュリティコード、郵便番号を使用してクレジットカードフォームに入力します。 |

#### 銀行へのリダイレクト

| 決済手段             | シナリオ                                                                                                             | テスト方法                                                                                                           |
| ---------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Bancontact、iDEAL | 顧客は、リダイレクトベースの即時通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | リダイレクトベースの任意の支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払い失敗)** をクリックします。           |
| Pay by Bank      | 顧客はリダイレクトベースの、[遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法で支払いに成功します。 | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Complete test payment (テスト支払い完了)** をクリックします。                    |
| Pay by Bank      | 顧客は、リダイレクトベースの遅延通知型の支払い方法のリダイレクトページで、認証に失敗しました。                                                                  | 支払い方法を選択し、必要な情報を入力して、支払いを確定します。その後、リダイレクトページで **Fail test payment (テスト支払いを失敗させる)** をクリックします。                    |
| BLIK             | BLIK による支払いはさまざまな理由で失敗します。即時の失敗 (コードの有効期限切れや無効など)、遅延型のエラー (銀行による拒否など)、またはタイムアウト (顧客が時間内に応答しなかったなど) などがあります。      | メールパターンを使用して[さまざまな失敗をシミュレーションします。](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures) |

#### 口座引き落とし

| 決済手段           | シナリオ                                                                         | テスト方法                                                                                                                   |
| -------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| SEPA ダイレクトデビット | 顧客が SEPA ダイレクトデビットによる支払いに成功しました。                                             | 口座番号 `AT321904300235473204` を使用して、フォームに入力します。確定された PaymentIntent のステータスはまず、processing に移行し、3 分後に succeeded ステータスに移行します。 |
| SEPA ダイレクトデビット | 顧客の Payment Intent のステータスが、`processing` から `requires_payment_method` に移行します。 | 口座番号 `AT861904300235473202` を使用して、フォームに入力します。                                                                           |

実装内容をテストするためのその他の情報については、[テスト](https://docs.stripe.com/testing.md)をご覧ください。

## Optional: Apple Pay を有効にする

### Apple 加盟店 ID を登録する

Apple Developer Web サイトで [新規 ID を登録](https://developer.apple.com/account/resources/identifiers/add/merchant) して、Apple 加盟店 ID を取得します。

フォームに説明と ID を入力します。説明はお客様の記録用であり、後で変更できます。アプリの名前を ID として使用することをお勧めします (`merchant.com.{{YOUR_APP_NAME}}` など)。

### 新しい Apple Pay 証明書を作成する

支払いデータを暗号化するためのアプリの証明書を作成します。

ダッシュボードの [iOS certificate settings (iOS 証明書の設定)](https://dashboard.stripe.com/settings/ios_certificates) に移動して、**新規アプリケーションを追加**をクリックし、表示されるガイドに従います。

証明書署名リクエスト (CSR) ファイルをダウンロードして、Apple Pay の利用を可能にする安全な証明書を Apple から取得します。

1 つの CSR ファイルを使用して証明書を 1 つだけ発行する必要があります。Apple 加盟店 ID を切り替えた場合、ダッシュボードの [iOS Certificate Settings (iOS 証明書の設定)](https://dashboard.stripe.com/settings/ios_certificates) に移動して、新しい CSR と証明書を取得する必要があります。

### Xcode を使用して組み込む

Apple Pay ケイパビリティをアプリに追加します。Xcode でプロジェクト設定を開き、**Signing & Capabilities (署名およびケイパビリティ)** タブを選択して、**Apple Pay** ケイパビリティを追加します。この段階で開発者アカウントへのログインを要求される場合があります。前の手順で作成した加盟店 ID を選択すると、アプリで Apple Pay を受け付けられるようになります。
![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png)

Xcode で Apple Pay ケイパビリティを有効化する

### Apple Pay を追加する

#### 1 回限りの支払い

`StripeProvider` を作成する際に、加盟店 ID を渡します。

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

function App() {
  return (
    <StripeProvider
      publishableKey="<<YOUR_PUBLISHABLE_KEY>>"
      merchantIdentifier="MERCHANT_ID"
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

`initPaymentSheet` を呼び出す際に、[ApplePayParams](https://stripe.dev/stripe-react-native/api-reference/modules/PaymentSheet.html#ApplePayParams) を渡します。

```javascript
await initPaymentSheet({
  // ...
  applePay: {
    merchantCountryCode: 'US',
  },
});
```

#### 継続支払い

`initPaymentSheet` を呼び出す際に、`merchantCountryCode` をビジネスの国コードに設定して、[ApplePayParams](https://stripe.dev/stripe-react-native/api-reference/modules/PaymentSheet.html#ApplePayParams) を渡します。

継続課金に関する [Apple のガイドライン](https://developer.apple.com/design/human-interface-guidelines/apple-pay#Supporting-subscriptions)に従い、決済予定の金額 (「月額 59.95 USD」など)を含む `cardItems` を設定し、その中に [RecurringCartSummaryItem](https://stripe.dev/stripe-react-native/api-reference/modules/ApplePay.html#RecurringCartSummaryItem) を含める必要があります。

`type` を `PaymentRequestType.Recurring` に設定して `request` を設定することで、[マーチャントトークン](https://developer.apple.com/apple-pay/merchant-tokens/)を導入することもできます。

Apple Pay で継続支払いを使用する方法について、詳細は [Apple の PassKit に関するドキュメント](https://developer.apple.com/documentation/passkit/pkpaymentrequest)をご覧ください。

#### iOS (React Native)

```javascript
const initializePaymentSheet = async () => {
  const recurringSummaryItem = {
    label: 'My Subscription',
    amount: '59.99',
    paymentType: 'Recurring',
    intervalCount: 1,
    intervalUnit: 'month',
    // Payment starts today
    startDate: new Date().getTime() / 1000,

    // Payment ends in one year
    endDate: new Date().getTime() / 1000 + 60 * 60 * 24 * 365,
  };

  const {error} = await initPaymentSheet({
    // ...
    applePay: {
      merchantCountryCode: 'US',
      cartItems: [recurringSummaryItem],
      request: {
        type: PaymentRequestType.Recurring,
        description: 'Recurring',
        managementUrl: 'https://my-backend.example.com/customer-portal',
        billing: recurringSummaryItem,
        billingAgreement:
          "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'",
      },
    },
  });
};
```

### 注文の追跡

iOS 16 以降で[注文の追跡](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking)情報を追加するには、`setOrderTracking` コールバック関数を設定します。Stripe は決済の完了後、iOS が Apple Pay 支払い画面を閉じる前にご使用の実装を呼び出します。

`setOrderTracking` コールバック関数の実装で、完了した注文の注文の詳細をサーバーから取得し、指定された `completion` 関数にその詳細を渡します。

注文の追跡の詳細については、[Apple のウォレットでの注文に関するドキュメント](https://developer.apple.com/documentation/walletorders)をご覧ください。

#### iOS (React Native)

```javascript
await initPaymentSheet({
  // ...
  applePay: {
    // ...
    setOrderTracking: async complete => {
      const apiEndpoint =
        Platform.OS === 'ios'
          ? 'http://localhost:4242'
          : 'http://10.0.2.2:4567';
      const response = await fetch(
        `${apiEndpoint}/retrieve-order?orderId=${orderId}`,
        {
          method: 'GET',
          headers: {
            'Content-Type': 'application/json',
          },
        },
      );
      if (response.status === 200) {
        const orderDetails = await response.json();
        // orderDetails should include orderIdentifier, orderTypeIdentifier,
        // authenticationToken and webServiceUrl
        complete(orderDetails);
      }
    },
  },
});
```

## Optional: Google Pay を有効にする

### 実装方法を設定する

Google Pay を使用するには、まず以下を **AndroidManifest.xml** の `<application>` に追加し、Google Pay API を有効化します。

```xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>
```

詳細は、Google Pay の Android 向け [Google Pay API を設定する](https://developers.google.com/pay/api/android/guides/setup) を参照してください。

### Google Pay を追加する

`PaymentSheet` を初期化する際に、`merchantCountryCode` にビジネスの国コードを設定し、`googlePay` を true に設定します。

`testEnv` パラメーターを渡して、テスト環境を使用することもできます。Google Pay は、物理的な Android デバイスでのみテストできます。[React Native ドキュメント](https://reactnative.dev/docs/running-on-device)に従って、物理デバイスでアプリケーションをテストします。

```javascript
const { error, paymentOption } = await initPaymentSheet({
  // ...
  googlePay: {
    merchantCountryCode: 'US',
    testEnv: true, // use test environment
  },
});
```

## カードのスキャンを有効にする [クライアント側]

> Apple の iOS アプリの確認プロセスでは、カードのスキャン機能を有効にする必要があります。Android アプリの確認プロセスでは、カードのスキャン機能は必要ありませんが、Stripe ではこの機能を有効にすることを推奨しています。

### iOS

iOS をサポートするカードスキャン機能を有効にするには、アプリケーションの `Info.plist` の `NSCameraUsageDescription` (**プライバシー - カメラ利用の詳細**)を設定し、カメラにアクセスする理由を入力して下さい (例:「カードをスキャンするため」)。

### (任意) Android

カードスキャンサポートを有効にするには、[Google Pay & Wallet Console](https://pay.google.com/business/console?utm_source=devsite&utm_medium=devsite&utm_campaign=devsite) から Google Pay API への[本番アクセスをリクエスト](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access)します。

- Google Pay を有効にしている場合、対象のデバイスの UI でカードスキャン機能が自動的に利用可能になります。対象のデバイスの詳細については、[Google Pay API の制約](https://developers.google.com/pay/payment-card-recognition/debit-credit-card-recognition)をご覧ください。
- **重要:** カードスキャン機能は、[Google Pay & Wallet Console](https://pay.google.com/business/console) に登録された同じ署名キーで署名されたビルドにのみ表示されます。異なる署名キーを使用したテストまたはデバッグビルド (Firebase App Tester を通じて配布されたビルドなど) では、 **カードをスキャン** オプションは表示されません。プレリリースビルドでカードスキャンをテストするには、以下のいずれかを行う必要があります。
  - 本番環境の署名キーを使用してテストビルドに署名する
  - Google Pay & Wallet Console にテスト署名キーのフィンガープリントを追加する

## Optional: 画面をカスタマイズする

カスタマイズはすべて `initPaymentSheet` を使用して設定されます。

### デザイン

色やフォントなどをアプリの見た目や雰囲気に合わせてカスタマイズするには、[Appearance API](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=react-native) を使用します。

### 加盟店の表示名

`merchantDisplayName` を設定し、顧客に対して表示するビジネス名を指定します。デフォルトはアプリ名です。

```javascript
await initPaymentSheet({
  // ...
  merchantDisplayName: 'Example Inc.',
});
```

### ダークモード

デフォルトで `PaymentSheet` は、ユーザーのシステム全体の表示設定 (ライト/ダークモード) に合わせて自動的に調整されます。これを変更するには、 iOS で `style` プロパティを `alwaysLight` モードまたは `alwaysDark` モードに設定します。

```javascript
await initPaymentSheet({
  // ...
  style: 'alwaysDark',
});
```

Android では、アプリでライトモードまたはダークモードに設定します。

```
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

### デフォルトの請求詳細

PaymentSheet で収集される請求先情報のデフォルト値を設定するには、`defaultBillingDetails` プロパティを設定します。`PaymentSheet` の各フィールドに、指定した値が事前に読み込まれます。

```javascript
await initPaymentSheet({
  // ...
  defaultBillingDetails: {
      email: 'foo@bar.com',
      address: {
        country: 'US',
      },
  },
});
```

### 請求詳細を収集する

`billingDetailsCollectionConfiguration` を使用して、PaymentSheet で請求先情報を収集する方法を指定します。

顧客の名前、メールアドレス、電話番号、住所を収集できます。

支払い方法に必要な値を収集しない場合は、以下を実行する必要があります。

1. `PaymentSheet` によって収集されない値を `defaultBillingDetails` プロパティに関連付けます。
1. `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` を `true` に設定します。

```javascript
await initPaymentSheet({
  // ...
  defaultBillingDetails: {
    email: 'foo@bar.com',
  },
  billingDetailsCollectionConfiguration: {
    name: PaymentSheet.CollectionMode.ALWAYS,
    email: PaymentSheet.CollectionMode.NEVER,
    address: PaymentSheet.AddressCollectionMode.FULL,
    attachDefaultsToPaymentMethod: true
  },
});
```

> 情報の収集に適用される法律については、弁護士に相談してください。電話番号は、取引に必要な場合にのみ収集してください。

## Optional: UI で支払いを完了する

支払い画面を表示して支払い方法の詳細のみを収集し、その後 `confirm` メソッドを呼び出して、アプリの UI で支払いを完了できます。これは、カスタムの購入ボタンがある場合や、支払いの詳細を収集した後で追加のステップが必要な場合に便利です。
![](https://b.stripecdn.com/docs-statics-srv/assets/react-native-multi-step.84d8a0a44b1baa596bda491322b6d9fd.png)

> サンプルの組み込みは、[Stripe の GitHub からご利用いただけます](https://github.com/stripe/stripe-react-native/blob/master/example/src/screens/PaymentsUICustomScreen.tsx)。

1. まず `initPaymentSheet` を呼び出し、`customFlow: true` を渡します。`initPaymentSheet` は、顧客の支払い方法を示す画像とラベルが格納された、最初の支払いオプションで解決されます。これらの詳細で UI を更新します。

```javascript
const {
  initPaymentSheet,
  presentPaymentSheet,
  confirmPaymentSheetPayment,
} = useStripe()

const { error, paymentOption } = await initPaymentSheet({
  customerId: customer,
  customerEphemeralKeySecret: ephemeralKey,
  paymentIntentClientSecret: paymentIntent,
  customFlow: true,
  merchantDisplayName: 'Example Inc.',
});
// Update your UI with paymentOption
```

1. `presentPaymentSheet` を使用して支払いの詳細を収集します。顧客が操作を完了すると、シートは自動的に閉じられ、promise が解決されます。UI は選択された支払い方法の詳細で更新されます。

```javascript
const { error, paymentOption } = await presentPaymentSheet();
```

1. `confirmPaymentSheetPayment` を使用し、支払いを確定します。これは、支払いの結果で解決されます。

```javascript
const { error } = await confirmPaymentSheetPayment();

if (error) {
  Alert.alert(`Error code: ${error.code}`, error.message);
} else {
  Alert.alert(
    'Success',
    'Your order is confirmed!'
  );
}
```

`allowsDelayedPaymentMethods` を true に設定すると、アメリカの銀行口座などの [遅延通知型](https://docs.stripe.com/payments/payment-methods.md#payment-notification)の支払い方法を使用できます。これらの支払い方法では、`PaymentSheet` が完了した時点では最終的な支払いステータスが判明せず、後になって成功または失敗が確定します。このようなタイプの支払い方法に対応する場合は、注文が確定済みであることを顧客に通知し、支払いが成功した場合にのみ注文のフルフィルメント (商品の発送など) を実行するようにします。


# コーディング不要

> This is a コーディング不要 for when platform is no-code. View the full page at https://docs.stripe.com/connect/end-to-end-marketplace?platform=no-code.

このガイドでは、コードを記述せずに、顧客から決済を受け付け、売上を売り手やサービスプロバイダーの銀行口座に移動する方法を説明します。以下に該当する場合に、このガイドをお使いください。

- コードを記述せずに、顧客から決済を受け付け、売り手またはサービスプロバイダーに入金したい場合。
- コードを記述せずに、プロダクトマーケットフィット (PMF) を素早くテストしたい場合。
- お客様が、(他の人のビジネス運営を支援するためにソフトウェアを販売する SaaS プラットフォームではなく) 最終顧客に直接販売するマーケットプレイスの場合 。

この例では、T シャツのアーティストが、カスタムした T シャツを販売するマーケットプレイスを構築します。このガイドの概念を使用し、他のビジネス用途にも応用できます。

## 前提条件

1. [プラットフォームを登録](https://dashboard.stripe.com/connect)します。
1. [ダッシュボードでビジネスの詳細の確認と追加](https://dashboard.stripe.com/account/onboarding)。
1. [プラットフォームプロフィール](https://dashboard.stripe.com/connect/settings/profile)を完成させます。
1. [Stripe ダッシュボードの設定ページ](https://dashboard.stripe.com/settings/connect/stripe-dashboard/branding)で Connect ブランド設定をカスタマイズし、Checkout の[ブランディング設定ページ](https://dashboard.stripe.com/settings/branding)で決済用のリンクのブランド設定をカスタマイズします。

## 連結アカウントを作成する

売り手またはサービスプロバイダーがマーケットプレイスに登録したら、お客様はユーザーアカウント (「連結アカウント」と呼ばれる) を作成し、売上を各ビジネスの銀行口座に移動できるようにする必要があります。連結アカウントは、売り手またはサービスプロバイダーを表します。T シャツのマーケットプレイスの例では、連結アカウントは T シャツのアーティストを示します。

### 連結アカウントのアカウント登録リンクを作成する

#### Accounts v2

- [連結アカウント](https://dashboard.stripe.com/connect/accounts)ページに移動し、**+ 作成**をクリックして新しい連結アカウントを作成します。
- **加盟店** を選択し、**次へ** をクリックします
- **アカウントのプロパティ** の **編集** をクリックします
- **Stripe ダッシュボードへのアクセス** に **Express** を選択し、**保存** をクリックします
- **作成** をクリックしてアカウントを作成し、オンボーディングリンクを生成します。これはメール、SMS、その他の方法を使用して売り手や代行業者と共有できます。このリンクは一般には公開しないでください。
![新しいアカウントを作成するモーダル (連結アカウントを登録する際に使用する生成済みの Express リンクを表示)](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-v2-express-link.9b4b6bc618d0ecab2b0f2a146f600915.png)

アカウント登録リンクを作成する

#### Accounts v1

- [連結アカウント](https://dashboard.stripe.com/connect/accounts)ページに移動し、**+ 作成**をクリックして新しい連結アカウントを作成します。
- アカウントタイプに **Express** を選択し、この連結アカウントが所在する国を選択します。サポート対象国のプラットフォームであれば、Stripe は [Stripe の他のサポート対象国で連結アカウントを作成](https://docs.stripe.com/connect/express-accounts.md#onboarding-express-accounts-outside-of-your-platforms-country)できるようにしています。
- **続行**をクリックして、アカウント登録リンクを生成します。これは、メール、 SMS、その他の方法を使用して売り手やサービスプロバイダーと共有できます。このリンクは、一般には公開しないでください。
![新しいアカウントを作成するモーダル (連結アカウントを登録する際に使用する生成済みの Express リンクを表示)](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-v1-express-link.0ce2e3df98419aae23f88c5cb77ca3f4.png)

アカウント登録リンクを作成する

このリンクから売り手やサービスプロバイダーを登録フォームに誘導し、そこで本人確認情報や銀行口座情報を入力してマーケットプレイスに登録してもらいます。T シャツのマーケットプレイスの例では、T シャツを制作したアーティストとこのリンクを共有し、アカウント登録してもらうことになります。このリンクは、1 人 (1 社) の売り手またはサービスプロバイダーのみが使用でき、90 日後に期限切れになります。アカウント登録フローが完了すると、[連結アカウント](https://dashboard.stripe.com/connect/accounts)ページでアカウントの詳細を確認できるようになります。売り手またはサービスプロバイダーを追加するたびに、このステップを繰り返すようにしてください。
![連結アカウントのリストビューに表示される 1 つのアカウント](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-connected-accounts.a62a6dc14ef6c95ae5a1e36801090945.png)

## 決済を受け付ける決済用のリンクを作成する

連結アカウントを作成したら、顧客から決済を受け付ける Payment Link を作成します。コードを記述する必要はありません。このリンクをマーケットプレイスの顧客に送信すると、Stripe 上の決済画面が表示され、顧客はそこで決済できます。T シャツのマーケットプレイスの例では、顧客はマーケットプレイスを通じて T シャツを購入し、T シャツをデザインおよび作成したアーティストへの支払いが行われます。設定するには、[Payment Links ページ](https://dashboard.stripe.com/payment-links)で **+リンクを作成** をクリックし、手順に従います。

### ステップ 2.1: 商品を追加する

特定の商品と価格に対して Payment Links を設定するため、まず販売する[商品を追加](https://support.stripe.com/questions/how-to-create-products-and-prices)します。**+新しい商品を追加** をクリックして商品を追加します。
![決済用リンク作成フォームの最初のページ](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-empty-payment-link.9885cf82263d39d2be55c4fbdcbcbb9f.png)

商品名、説明、価格を設定します。これらはすべて、顧客がリダイレクトされる決済ページで顧客に対して表示されます。新しい商品の情報を入力したら、**+商品を追加**をクリックして商品を追加します。この例では、木の模様のM サイズの T シャツ商品を追加するため、この特定の商品の決済用リンクを設定します。S サイズの T シャツや、他のデザインの T シャツも販売する場合には、上記のステップに従って新しい決済用リンクと新しい商品を作成します。
![決済用リンク作成フォーム内の商品作成モーダル](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-create-product.ce265a710c21ecb80ac7715dc240721a.png)

### ステップ 2.2: 決済用のリンクをカスタマイズする

決済用リンクをカスタマイズして、顧客がプロモーションコードを入力したり、商品の数量を変更したり、または配送や請求先住所を入力したりできるようにできます。T シャツのマーケットプレイスの例では、顧客がさまざまな枚数の T シャツを購入できるようにします。また、T シャツを発送するため、顧客の配送先住所も収集する必要もあります。この両方を実現するには、**顧客が数量を調整できるようにする**および**顧客の住所を収集**を選択し、**次へ**をクリックします。

### ステップ 2.3: 連結アカウントに支払うタイミングを決定する

連結アカウントに入金するには、2 つのオプションがあります。

- 決済用のリンクで回収した売上を使用して、どの連結アカウントに支払うかがすでに分かっている場合、自動的に入金できます。
- ただし、連結アカウントが事前に分からない場合や、複数の連結アカウントに支払う必要がある場合には、後で入金できます。

#### 自動的に入金する

#### 支払い先の連結アカウントを選択する

**連結アカウントに支払いを分割**というチェックボックスを選択します。このチェックボックスを選択すると、この決済用のリンクを通じて顧客が商品を購入した場合に、連結アカウントは自動的に支払いを受けることができます。この例では、顧客が T シャツを購入するたびに T シャツのアーティストであるジェイミーさんに支払いが行われます。このようにするには、ジェイミーさんを連結アカウントとして設定します。

#### プラットフォーム手数料を指定する

マーケットプレイスがこの支払いの一部を保持するには、プラットフォーム手数料を指定できます。この手数料は、決済用のリンクを使用する支払い 1 件当たりの固定金額です。数量、割引、税額に応じて金額が変動することはなく、合計購入額が上限に指定されます。この例では、T シャツマーケットプレイスは販売ごとに 1 USD のプラットフォーム手数料を徴収し、残りの支払い額 (9 USD) を T シャツのアーティストに送金します。顧客が T シャツを 2 枚購入したり、プロモーションコードを使用したり、10 USD の購入に加えて追加の税金を支払う必要がある場合でも、T シャツマーケットプレイスは引き続き販売ごとに 1 USD のプラットフォーム手数料を受け取ります。継続支払いの商品 (サブスクリプション) の場合は、取引合計額のパーセンテージとしてプラットフォーム手数料を指定できます。
![決済用リンク作成フォームの 2 ページ目。このページには、連結アカウントに売上を振り分けるためのオプションが含まれます。](https://b.stripecdn.com/docs-statics-srv/assets/no-code-connect-create-payment-link-page-2.465b89cd12b53c1e3e623a0a3b03ffb0.png)

支払いを連結アカウントと分割するように決済用リンクを設定したら、**+リンクを作成**をクリックして決済用の URL リンクを生成します。

顧客が支払いをすると、Stripe は連結アカウントの保留中の残高に全額送金し、販売促進の収入として、手数料の金額をプラットフォームのアカウントに送金します。次に、Stripe はプラットフォームの手数料の金額から Stripe 手数料を差し引きます。この資金フローは、[デスティネーション支払い](https://docs.stripe.com/connect/destination-charges.md)と呼ばれます。

#### 後払い

#### 連結アカウントに後で支払う

場合によっては、購入時に自動的に決済するのではなく、後で連結アカウントに資金を手動で送金したい場合があります。これは、資金を受け取るべき連結アカウントがまだ分からない場合や、1 度の販売で複数の連結アカウントに決済する必要がある場合などに該当します。以下に例を挙げます。

- 2 人のアーティストのコラボによる T シャツを販売していて、それぞれが売り上げの半分を受け取る場合。
- 複数のアーティストのいずれかによって発送が行われる T シャツを販売していて、誰が配送するかまだ分からない場合。

顧客から支払いを受け付けるための決済用リンクを作成する場合、**連結アカウントで支払いを分割**を設定して_いない_ことを確認してから、**リンクを作成**をクリックして決済用リンクを生成します。連結アカウントに送金する準備ができたら、連結アカウントの詳細ページの**残高**セクションに移動し、**売上の送金**をクリックします。Stripe 内部において、この売上フローは[支払いと送金別方式](https://docs.stripe.com/connect/separate-charges-and-transfers.md)と呼ばれます。

## 決済用のリンクを顧客と共有する

決済用のリンクができたので、その決済用の URL リンクをコピーし、ウェブサイトやソーシャルメディアで共有します。顧客が決済用の URL リンクをクリックすると、貴社のカスタムの決済ページ (以下の例) が表示され、顧客はそこに支払い情報を入力できます。顧客は、カード、Apple Pay、または Google Pay を使用してモバイルまたはデスクトップから支払いできます。
![](https://d37ugbyn3rpeym.cloudfront.net/docs/connect/video/no-code-connect-mobile-payment-link.mp4)
## 支払い後

### ステップ 4.1 支払いを表示する

[決済画面](https://dashboard.stripe.com/payments)に移動して、ビジネスが受け付けた決済のリストを確認します。各決済をクリックすると、配送先住所 (徴収する場合) などの詳細を確認できます。ビジネスが各決済で回収した[プラットフォーム手数料](https://dashboard.stripe.com/connect/application_fees)を確認するか、[残高ページ](https://dashboard.stripe.com/balance/overview)に移動して売上合計を確認できます。

### ステップ 4.2 フルフィルメントを実行する

支払いの完了後、商品の*フルフィルメント* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected)を処理する必要があります。T シャツマーケットプレイスの例では、支払い後に T シャツを購入者に配送することになります。

## Optional: 支払い方法をさらに追加する

Payment Links は [20 種類以上の決済手段](https://docs.stripe.com/payments/payment-methods/payment-method-support.md#product-support)をサポートしています。[決済手段設定](https://dashboard.stripe.com/settings/payment_methods)で決済手段を有効にできます。決済手段を有効にすると、Stripe は購入完了率を高める可能性が最も高く、通貨と顧客の店舗に最も関連性の高い決済手段を動的に表示します。

> Stripe は 2022 年 1 月 25 日にサポート対象の支払い方法を拡張しました。この日より前に作成された決済用リンクは、カード支払いとウォレットのみに対応します。有効にする支払い方法を増やすには、新しいリンクを作成します。

銀行口座引き落としや店舗支払いなどの一部の支払い方法では、支払いの確定までに 2 ～ 14 日かかります。Webhook を使用することで、支払いが完了したときに通知を受け取り、フルフィルメントを開始できます。詳細は、[フルフィルメントガイド](https://docs.stripe.com/checkout/fulfillment.md#create-payment-event-handler)をご覧ください。


## 不審請求の申請

お客様は支払いの[売上処理加盟店](https://docs.stripe.com/connect/destination-charges.md#settlement-merchant)であるため、お客様のプラットフォームは不審請求の申請に対する責任を負います。不審請求の申請に対応するための[ベストプラクティス](https://docs.stripe.com/disputes/responding.md)を必ず理解するようにしてください。

## 入金

デフォルトでは、連結アカウントに送金する売上は、連結アカウントの [Stripe 残高](https://docs.stripe.com/connect/account-balances.md)に追加され、ローリング方式によって毎日入金されます。*入金* (A payout is the transfer of funds to an external account, usually a bank account, in the form of a deposit)頻度を変更するには、連結アカウントの詳細ページに移動し、**残高**セクションの右端のボタンをクリックして、**入金スケジュールの編集**を選択します。

## 返金

返金を行うには、[支払い](https://dashboard.stripe.com/payments)ページに移動します。返金する支払いの左側にあるチェックボックスをクリックして、個々の支払いを選択します。支払いを選択すると、ページの右上隅に**返金**ボタンが表示されます。**返金**ボタンをクリックして、選択したすべての支払いに対する顧客への返金を行います。

> 連結アカウントは、デフォルトでは [Express ダッシュボード](https://docs.stripe.com/connect/express-dashboard.md) からの決済の返金を開始できません。連結アカウントが Express ダッシュボードを使用している場合、返金を処理するか、[Express ダッシュボードの機能](https://docs.stripe.com/connect/express-dashboard.md#express-dashboard-features) をカスタマイズして返金を処理できるようにすることができます。

## See also

- [ダッシュボードで連結アカウントを管理する](https://docs.stripe.com/connect/dashboard.md)
- [返金](https://docs.stripe.com/connect/direct-charges.md#issue-refunds)
- [明細書表記をカスタマイズする](https://docs.stripe.com/connect/statement-descriptors.md)
- [複数通貨を処理する](https://docs.stripe.com/connect/currencies.md)
- [Express ダッシュボード](https://docs.stripe.com/connect/express-dashboard.md)