# AgentCore 支払いのクイックスタート
<a name="payments-getting-started"></a>

このチュートリアルでは、AgentCore 支払いを設定し、最初のマイクロトランザクションを処理する方法について説明します。最終的に、エージェントはテストネットワークの x402 プロトコルを使用してリソースの料金を支払います。

支払いは 2 つの方法で設定できます。
+  [AgentCore Payments スキルの使用](#payments-getting-started-skill) — Kiro、Claude Code、Codex などの AI コーディングエージェントとのガイド付き会話を通じてすべてのリソースをプロビジョニングする自動セットアップエクスペリエンス。このスキルは、CLI コマンド、SDK スクリプト、フレームワークのワイヤリングを自動的に処理します。
+  [CLI、SDK、または Boto3 の使用](#payments-getting-started-manual) — AgentCore CLI、 AWS SDK、または AWS CLI を直接使用するstep-by-stepの手動セットアップ。

## AgentCore Payments スキルの使用
<a name="payments-getting-started-skill"></a>

AgentCore Payments スキルは、インタラクティブなガイド付きエクスペリエンスを通じてセットアッププロセス全体を自動化します。次のリソースをプロビジョニングします。
+  **PaymentCredentialProvider** — 支払いプロバイダーの認証情報を AgentCore Identity に保存します。
+  **Payment Manager** — 支払いオペレーションを調整する最上位のリソース。
+  **Payment Connector** — AgentCore CLI を介してマネージャーを認証情報にリンクします。
+  **支払い手段** — エージェントがユーザーに代わってマーチャントの支払いに使用する暗号ウォレット。
+  **Payment Session** — 支出制限のある時間制限付きコンテキスト。

また、このスキルはフレームワークに依存しないツールを使用してエージェントに支払いをルーティングするため、Strands、LangGraph、OpenAI Agents SDK、または任意の Python フレームワークで動作します。

### 前提条件
<a name="payments-getting-started-skill-prereqs"></a>

開始する前に、以下を確認してください。
+  ** AWS 認証情報が設定されたアカウント** (`aws configure`)
+  **AgentCore 支払いが利用可能な AWS リージョン** — us-east-1、us-west-2、eu-central-1、または ap-southeast-2。[「サポートされている AWS リージョン](agentcore-regions.md)」を参照してください。
+  **Node.js 20\+** がインストールされている (スキルは AgentCore CLI を自動的にインストールします)
+  **有料エンドポイントにアクセスするエージェント** — このスキルにより、エージェントは x402 で保護された APIsに対して料金を支払うことができます。テストには、サンドボックスエンドポイント を使用できます`https://sandbox.node4all.com/v1/x402-test`。
+  AI **コーディングエージェントにインストールされている Agent [Toolkit for AWS](https://github.com/aws/agent-toolkit-for-aws) `aws-agents`プラグイン**:  
**Example**  

------
#### [ Claude Code ]

  ```
  /plugin marketplace add aws/agent-toolkit-for-aws
  /plugin install aws-agents@agent-toolkit-for-aws
  ```

------
#### [ Codex ]

  プラグインはマーケットプレイスマニフェストから自動的に検出されます。マーケットプレイスを追加するには、次のコマンドを実行します。

  ```
  codex plugin marketplace add aws/agent-toolkit-for-aws
  ```

------

### スキルの呼び出し
<a name="payments-getting-started-skill-invoke"></a>

支払いスキルは、 エージェントツールキットの`agents-build`スキルの一部です。 [AWS](https://github.com/aws/agent-toolkit-for-aws)これをトリガーするには、AI コーディングエージェントでインテントを記述します。例えば、次のようになります。
+ `aws-agents` 「プラグインの`agents-build`スキルを使用してエージェントに支払いを追加する」
+ `aws-agents` 「プラグインの`agents-build`スキルを使用してエージェントのマイクロトランザクションを設定する」
+ `aws-agents` 「 プラグインの`agents-build`スキルを使用して 402 Payment Required レスポンスを処理する必要があります」
+ `agents-build` 「スキルイン`aws-agents`プラグインを使用して x402 で保護された APIs」

スキルは支払い関連のインテントを検出し、支払いワークフローを自動的にロードします。

### スキルの動作
<a name="payments-getting-started-skill-flow"></a>

スキルは、支払いインフラストラクチャをend-to-endプロビジョニングする自動プロセスを実行します。スキルはほとんどのステップを自動的に実行し、入力のために 2 回一時停止します。

1. AgentCore CLI を検証またはインストールし、プロジェクトをセットアップします

1. 支払いマネージャーを作成します。

1.  **一時停止** — `agentcore add payment-connector`を実行してプロバイダーシークレット (Coinbase CDP または Stripe Privy 認証情報) を入力します。

1. リソースを AWS アカウントにデプロイします (`agentcore deploy -y`)

1. フレームワークに依存しない支払いツール (`x402_payment_tool.py`) をエージェントにワイヤリングする

1. SDK を介してユーザーごとのウォレット (計器) と予算制限付きセッションを作成します。

1.  **一時停止** — [Circle 蛇口ウェブサイトのウォレット (委任) を承認し、テストネット USDC ](https://faucet.circle.com/)で資金を提供します。

1. 環境変数を設定し、有料エンドポイントに対してテスト支払いを実行します

コネクタコマンドを実行する前に、プロバイダーから認証情報を取得します。
+  **Coinbase CDP** — [Coinbase Developer Platform](https://portal.cdp.coinbase.com/) ウェブサイトの API キー ID、API キーシークレット、ウォレットシークレット (委任署名が有効）。
+  **Stripe Privy** — [Privy ダッシュボード](https://dashboard.privy.io/)ウェブサイトのアプリ ID、アプリシークレット、認可 ID、認可プライベートキー。

実行が成功すると`x402_fetch`、エージェントが を呼び出し、 を検出し`402`、AgentCore SDK を介して支払いを決済し、有料コンテンツ`200`で再試行して を返します。

## CLI、SDK、または Boto3 の使用
<a name="payments-getting-started-manual"></a>

このセクションでは、AgentCore CLI、 AWS CLI、または AWS SDK (Boto3) を使用して、各ステップを手動で説明します。

### 前提条件
<a name="payments-getting-started-manual-prereqs"></a>

開始する前に、以下を確認してください。
+  ** AWS 認証情報が設定されたアカウント** (`aws configure`)
+  **Python 3.10 以降**がインストールされている
+  **AgentCore 支払いが利用可能な AWS リージョン** — us-east-1、us-west-2、eu-central-1、または ap-southeast-2。[「サポートされている AWS リージョン](agentcore-regions.md)」を参照してください。

必要なパッケージをインストールします。

```
pip install boto3 bedrock-agentcore[strands-agents] strands-agents strands-agents-tools
```

認証情報が設定されていることを確認します。

```
aws sts get-caller-identity
```

**ヒント**  
AgentCore CLI v0.19.0 以降がインストールされている場合は、ステップ 2、3、5、6 で SDK の代わりに CLI コマンドを使用できます。以下の各ステップは、両方のオプションを示しています。

### ステップ 1: 支払いプロバイダーの認証情報を取得する
<a name="payments-getting-started-provider-credentials"></a>

AgentCore 支払いは、ウォレットオペレーションのために外部支払いプロバイダーに接続します。先に進む前に、サポートされているプロバイダーのいずれかの認証情報が必要です。

**Example**  

1. [Coinbase 開発者プラットフォーム](https://docs.cdp.coinbase.com/api-reference/v2/authentication)にログインし、プロジェクトを作成または選択します。

1. API キーを生成し、**API キー ID**、**API キーシークレット**、**およびウォレットシークレット**を書き留めます。

1. Project **** > **Wallets** > **Non-custodial Wallet** > **Security** で、**委任署名**を有効にします。
次のステップでは、次の 3 つの値を使用します。  


| [認証情報] | 説明 | 
| --- | --- | 
|  `API Key ID`  | CDP プロジェクトのパブリック識別子 | 
|  `API Key Secret`  | API リクエストに署名するためのプライベートシークレット | 
|  `Wallet Secret`  | 暗号化ウォレットオペレーション (アドレスの取得、トランザクションの署名) のシークレット | 

1. [dashboard.privy.io](https://dashboard.privy.io/) で**専用の** Privy アプリを作成します。他の目的を果たすアプリは再利用しないでください。

1. アプリ設定からアプリ **ID** と**アプリシークレット**をコピーします。

1. **ウォレットインフラストラクチャ** > **認可**に移動し、**新しいキー**を選択して P-256 キーペアを生成します。
次のステップでは、次の 4 つの値を使用します。  


| [認証情報] | 説明 | 
| --- | --- | 
|  `App ID`  | Privy アプリケーション識別子 | 
|  `App Secret`  | server-to-server基本認証のシークレット | 
|  `Authorization ID`  | P-256 キーペアからのパブリックキー識別子 | 
|  `Authorization Private Key`  | P-256 キーペアからのプライベートキー | 

セキュリティのベストプラクティスや認証情報のローテーションなどの詳細については、[「前提条件](payments-prerequisites.md)」を参照してください。

### ステップ 2: AgentCore Identity に認証情報を保存する
<a name="payments-getting-started-step2"></a>

支払いプロバイダーの認証情報を PaymentCredentialProvider として保存します。これにより、アプリケーションコードではなく AWS Secrets Manager にシークレットが保持されます。

**Example**  

```
import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-west-2")

credential_provider = client.create_payment_credential_provider(
    name="my-coinbase-credentials",
    credentialProviderVendor="CoinbaseCDP",
    coinbaseCdpConfig={
        "apiKeyId": "<YOUR_CDP_API_KEY_ID>",
        "apiKeySecret": "<YOUR_CDP_API_KEY_SECRET>",
        "walletSecret": "<YOUR_CDP_WALLET_SECRET>"
    }
)
CREDENTIAL_PROVIDER_ARN = credential_provider["credentialProviderArn"]
print(f"Credential provider created: {CREDENTIAL_PROVIDER_ARN}")
```

```
import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-west-2")

credential_provider = client.create_payment_credential_provider(
    name="my-privy-credentials",
    credentialProviderVendor="StripePrivy",
    stripePrivyConfig={
        "appId": "<YOUR_PRIVY_APP_ID>",
        "appSecret": "<YOUR_PRIVY_APP_SECRET>",
        "authorizationId": "<YOUR_PRIVY_AUTHORIZATION_ID>",
        "authorizationPrivateKey": "<YOUR_PRIVY_PRIVATE_KEY_BASE64>"
    }
)
CREDENTIAL_PROVIDER_ARN = credential_provider["credentialProviderArn"]
print(f"Credential provider created: {CREDENTIAL_PROVIDER_ARN}")
```

リクエストとレスポンスの完全なスキーマについては、 API リファレンスの[CreatePaymentCredentialProvider](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentCredentialProvider.html)」を参照してください。

#### CLI の代替方法: 認証情報を保存する
<a name="payments-getting-started-step2-cli"></a>

AgentCore CLI では、支払いコネクタを追加すると認証情報ストレージが自動的に実行されます (ステップ 3)。CLI パスを使用する場合は、このステップをスキップします。

### ステップ 3: Payment Manager とコネクタを作成する
<a name="payments-getting-started-step3"></a>

Payment Manager は、支払いオペレーションを調整する最上位のリソースです。Payment Connector は、マネージャーを支払いプロバイダーの認証情報にリンクします。これらのリソースを作成する前に、[AgentCore 支払いの IAM ロールの説明に従って、必要な IAM ロール](payments-iam-roles.md)を設定します。

**Example**  
JWT 認可やカスタムクレームを含むコンソールの詳細なチュートリアルについては、[「Payment Manager と Connector の作成](payments-create-manager.md)」を参照してください。  

1. [Amazon Bedrock AgentCore コンソール](https://console.aws.amazon.com/bedrock-agentcore/)を開きます。

1. ナビゲーションペインの**ビルド**で、**支払い**を選択します。

1. **Payment Manager の作成**を選択します。

1. Payment Manager **の名前**を入力します。

1. アクセス**許可で**、**新しいサービスロールを作成して使用する** (または既存のロールを選択する) を選択します。

1. **Inbound Auth **で、**IAM 認可に IAM ユーザー名を使用する** を選択します。

1. (オプション) **Payment connector** セクションで、コネクタの名前を選択し、既存のアウトバウンド認証を選択するか、プロバイダー (Coinbase または Stripe Privy) を選択して認証情報を入力して新しい認証を作成します。

1. **Payment Manager の作成**を選択します。
CLI は、認証情報プロバイダー、 Payment Manager、 Payment Connector を 1 つのフローに作成します。AgentCore プロジェクトディレクトリから、支払いマネージャーとコネクタを一緒に追加します。  
 **インタラクティブウィザード:**   

```
agentcore add payment-manager
```
ウィザードは、マネージャー名、パターン (インターセプター）、自動支払いトグル、デフォルトの使用制限を求めます。次に、コネクタを追加するかどうかを尋ね、プロバイダーの選択と認証情報の入力について説明します。  
 **非インタラクティブ (Coinbase CDP):**   

```
agentcore add payment-manager \
  --name my-payment-manager \
  --auto-payment \
  --default-spend-limit 5.00

agentcore add payment-connector \
  --manager my-payment-manager \
  --name my-coinbase-connector \
  --provider CoinbaseCDP \
  --api-key-id <YOUR_CDP_API_KEY_ID> \
  --api-key-secret <YOUR_CDP_API_KEY_SECRET> \
  --wallet-secret <YOUR_CDP_WALLET_SECRET>
```
 **非インタラクティブ (プライベート):**   

```
agentcore add payment-manager \
  --name my-payment-manager \
  --auto-payment \
  --default-spend-limit 5.00

agentcore add payment-connector \
  --manager my-payment-manager \
  --name my-privy-connector \
  --provider StripePrivy \
  --app-id <YOUR_PRIVY_APP_ID> \
  --app-secret <YOUR_PRIVY_APP_SECRET> \
  --authorization-id <YOUR_PRIVY_AUTHORIZATION_ID> \
  --authorization-private-key <YOUR_PRIVY_PRIVATE_KEY_BASE64>
```
追加したら、 をデプロイして支払いインフラストラクチャをプロビジョニングします。  

```
agentcore deploy
```
デプロイステップでは、IAM ロールを作成し、AgentCore Identity に認証情報を保存して、 Payment Manager と Connector をプロビジョニングします。出力に「支払いインフラストラクチャの作成」が表示されます。
AgentCore SDK は、1 回の呼び出しで Payment Manager、認証情報プロバイダー、コネクタを作成します。  

```
from bedrock_agentcore.payments import PaymentClient

payment_client = PaymentClient(region_name="us-west-2")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="my-first-payment-manager",
    payment_manager_description="Payment manager for my agent.",
    authorizer_type="AWS_IAM",
    role_arn="<YOUR_SERVICE_ROLE_ARN>",
    payment_connector_config={
        "name": "my-coinbase-connector",
        "description": "Coinbase CDP connector",
        "payment_credential_provider_config": {
            "name": "my-coinbase-provider",
            "credential_provider_vendor": "CoinbaseCDP",
            "credentials": {
                "api_key_id": "<YOUR_CDP_API_KEY_ID>",
                "api_key_secret": "<YOUR_CDP_API_KEY_SECRET>",
                "wallet_secret": "<YOUR_CDP_WALLET_SECRET>",
            },
        },
    },
    wait_for_ready=True,
    max_wait=300,
    poll_interval=5,
)

PAYMENT_MANAGER_ARN = response["paymentManager"]["paymentManagerArn"]
PAYMENT_CONNECTOR_ID = response["paymentConnector"]["paymentConnectorId"]
print(f"Payment Manager ARN: {PAYMENT_MANAGER_ARN}")
print(f"Connector ID: {PAYMENT_CONNECTOR_ID}")
```
Stripe Privy の場合は、 `payment_credential_provider_config`を `credential_provider_vendor: "StripePrivy"`および対応する Privy 認証情報に置き換えます。
Payment Manager を作成します。  

```
aws bedrock-agentcore-control create-payment-manager \
  --name "my-first-payment-manager" \
  --authorizer-type AWS_IAM \
  --role-arn "<YOUR_SERVICE_ROLE_ARN>" \
  --region us-west-2
```
マネージャーが`READY`ステータスに達したら、認証情報プロバイダーとコネクタを作成します。完全な CLI ワークフローについては[、「Payment Manager とコネクタ](payments-create-manager.md)の作成」を参照してください。 AWS 
まず、 Payment Manager を作成します (両方のプロバイダーで同じ）。  

```
import time

manager = client.create_payment_manager(
    name="my-first-payment-manager",
    authorizerType="AWS_IAM",
    roleArn="<YOUR_SERVICE_ROLE_ARN>"
)
PAYMENT_MANAGER_ARN = manager["paymentManagerArn"]
print(f"Payment Manager created: {PAYMENT_MANAGER_ARN}")

# Wait for the manager to reach READY state
while True:
    status = client.get_payment_manager(paymentManagerArn=PAYMENT_MANAGER_ARN)
    if status["status"] == "READY":
        break
    print(f"Status: {status['status']}... waiting")
    time.sleep(5)
```
次に、プロバイダーの Payment Connector を作成します。  
 **Coinbase CDP:**   

```
connector = client.create_payment_connector(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    name="my-coinbase-connector",
    paymentConnectorType="CoinbaseCDP",
    credentialProviderArn=CREDENTIAL_PROVIDER_ARN
)
PAYMENT_CONNECTOR_ID = connector["paymentConnectorId"]
print(f"Connector created: {PAYMENT_CONNECTOR_ID}")
```
 **プライベート:**   

```
connector = client.create_payment_connector(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    name="my-privy-connector",
    paymentConnectorType="StripePrivy",
    credentialProviderArn=CREDENTIAL_PROVIDER_ARN
)
PAYMENT_CONNECTOR_ID = connector["paymentConnectorId"]
print(f"Connector created: {PAYMENT_CONNECTOR_ID}")
```
サービスロールがない場合は、サービスロールの作成手順について [ AgentCore 支払いの IAM ロール](payments-iam-roles.md)を参照してください。コンソールは、ユーザーに代わってロールを作成することもできます。リクエストとレスポンスの完全なスキーマについては、 API リファレンスの[CreatePaymentManager](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentManager.html)」と[CreatePaymentConnector](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentConnector.html)」を参照してください。

### ステップ 4: 支払い手段を作成する
<a name="payments-getting-started-step4"></a>

支払い手段は、エージェントがユーザーに代わってマーチャントに支払うために使用する埋め込み暗号ウォレットです。各機器は、特定のブロックチェーンネットワークに関連付けられます。

**Example**  

```
from bedrock_agentcore.payments import PaymentManager

manager = PaymentManager(
    payment_manager_arn=PAYMENT_MANAGER_ARN,
    region_name="us-west-2"
)

instrument = manager.create_payment_instrument(
    user_id="test-user-123",
    payment_connector_id=PAYMENT_CONNECTOR_ID,
    payment_instrument_type="EMBEDDED_CRYPTO_WALLET",
    payment_instrument_details={
        "embeddedCryptoWallet": {
            "network": "ETHEREUM",
            "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}]
        }
    },
)
INSTRUMENT_ID = instrument["paymentInstrumentId"]
REDIRECT_URL = instrument["paymentInstrumentDetails"]["redirectUrl"]
print(f"Instrument created: {INSTRUMENT_ID}")
print(f"Fund the wallet at: {REDIRECT_URL}")
```

```
aws bedrock-agentcore create-payment-instrument \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-connector-id "$PAYMENT_CONNECTOR_ID" \
    --user-id "test-user-123" \
    --payment-instrument-type "EMBEDDED_CRYPTO_WALLET" \
    --payment-instrument-details '{
        "embeddedCryptoWallet": {
            "network": "ETHEREUM",
            "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}]
        }
    }' \
    --client-token "$(uuidgen)" \
    --region us-west-2
```
レスポンス`redirectUrl`から `paymentInstrumentId`と を保存します。

```
import uuid

dp_client = boto3.client("bedrock-agentcore", region_name="us-west-2",
    endpoint_url="https://bedrock-agentcore.us-west-2.amazonaws.com")

instrument = dp_client.create_payment_instrument(
    userId="test-user-123",
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    paymentConnectorId=PAYMENT_CONNECTOR_ID,
    paymentInstrumentType="EMBEDDED_CRYPTO_WALLET",
    paymentInstrumentDetails={
        "embeddedCryptoWallet": {
            "network": "ETHEREUM",
            "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}]
        }
    },
    clientToken=str(uuid.uuid4()),
)
INSTRUMENT_ID = instrument["paymentInstrumentId"]
REDIRECT_URL = instrument["paymentInstrumentDetails"]["redirectUrl"]
print(f"Instrument created: {INSTRUMENT_ID}")
print(f"Fund the wallet at: {REDIRECT_URL}")
```

完全なリクエストとレスポンスのスキーマについては、 API リファレンスの[CreatePaymentInstrument](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_CreatePaymentInstrument.html)」を参照してください。

#### ウォレットに資金を提供し、アクセス許可を付与する
<a name="payments-getting-started-step4-fund"></a>

エージェントが取引する前に、エンドユーザーはウォレットに資金を提供し、署名権限を付与する必要があります。ブラウザで上記のレスポンス`redirectUrl`から を開きます。ウォレットハブから、ユーザーは次のことができます。
+ 暗号転送、クレジットカード/デビットカード、Apple Pay、Google Pay、または ACH を使用してウォレットを補充する
+ エージェントに代わってトランザクションに署名するアクセス許可をエージェントに付与する

テスト環境の場合は、ウォレットに testnet USDC を注入します。

資金調達後、 になるまで計測ステータスをポーリングします`ACTIVE`。

**Example**  

```
instrument = manager.get_payment_instrument(
    user_id="test-user-123",
    payment_instrument_id=INSTRUMENT_ID
)
print(f"Status: {instrument['status']}")
```

```
aws bedrock-agentcore get-payment-instrument \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-instrument-id "$INSTRUMENT_ID" \
    --region us-west-2
```

```
while True:
    inst_status = dp_client.get_payment_instrument(
        paymentManagerArn=PAYMENT_MANAGER_ARN,
        paymentInstrumentId=INSTRUMENT_ID
    )
    if inst_status["status"] == "ACTIVE":
        print("Instrument is active and funded.")
        break
    print(f"Instrument status: {inst_status['status']}... waiting for funding")
    time.sleep(10)
```

プロバイダー別の資金フローの詳細については、「Funding [the wallet](payments-how-it-works.md#payments-how-it-works-funding-wallet)」を参照してください。

### ステップ 5: 支払いセッションを作成する
<a name="payments-getting-started-step5"></a>

支払いセッションは、オプションの支出制限がある時間制限付きコンテキストです。セッションの有効期限が切れるか、予算が枯渇した場合、エージェントはそのセッション内でそれ以上の支払いを行うことはできません。

**Example**  
CLI を使用する場合、セッションを手動で作成する必要はありません。`--auto-session` に渡す`agentcore invoke`と、 CLI は支払いマネージャーで設定したデフォルトの使用制限でセッションを作成または再利用します。  

```
agentcore invoke \
  --prompt "your prompt here" \
  --payment-instrument-id <INSTRUMENT_ID> \
  --auto-session \
  --payment-user-id test-user-123
```
SDK で作成した特定のセッションを使用するには、 `--payment-session-id` の代わりに を渡します`--auto-session`。

```
from bedrock_agentcore.payments import PaymentManager

manager = PaymentManager(
    payment_manager_arn=PAYMENT_MANAGER_ARN,
    region_name="us-west-2"
)

session = manager.create_payment_session(
    user_id="test-user-123",
    limits={"maxSpendAmount": {"value": "5.00", "currency": "USD"}},
    expiry_time_in_minutes=60
)
SESSION_ID = session["paymentSessionId"]
print(f"Session created: {SESSION_ID} (expires in 60 minutes, $5.00 limit)")
```

```
aws bedrock-agentcore create-payment-session \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --user-id "test-user-123" \
    --expiry-time-in-minutes 60 \
    --limits '{"maxSpendAmount": {"value": "5.00", "currency": "USD"}}' \
    --client-token "$(uuidgen)" \
    --region us-west-2
```

```
session = dp_client.create_payment_session(
    userId="test-user-123",
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    expiryTimeInMinutes=60,
    limits={"maxSpendAmount": {"value": "5.00", "currency": "USD"}},
    clientToken=str(uuid.uuid4()),
)
SESSION_ID = session["paymentSessionId"]
print(f"Session created: {SESSION_ID} (expires in 60 minutes, $5.00 limit)")
```
完全なリクエストとレスポンスのスキーマについては、 API リファレンスの[CreatePaymentSession](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_CreatePaymentSession.html)」を参照してください。

### ステップ 6: Strands エージェントで支払いを処理する
<a name="payments-getting-started-step6"></a>

すべてのリソースを配置したら、x402 支払いを自動的に処理する Strands エージェントを作成します。エージェントが有料エンドポイントを呼び出して HTTP 402 レスポンスを受信すると、支払いプラグインはトランザクションに署名し、リクエストを再試行します。

**Example**  
支払いコンテキストを使用してデプロイされたエージェントを呼び出します。CLI は実行時に支払い手段とセッションをエージェントに渡し、エージェントの x402 インターセプターは自動的に支払いを処理します。  

```
agentcore invoke \
  --prompt "Access the premium endpoint at https://example-x402-merchant.com/paid-api" \
  --payment-instrument-id <INSTRUMENT_ID> \
  --auto-session \
  --payment-user-id test-user-123
```
自動作成の代わりに明示的なセッションを渡すには:  

```
agentcore invoke \
  --prompt "Access the premium endpoint at https://example-x402-merchant.com/paid-api" \
  --payment-instrument-id <INSTRUMENT_ID> \
  --payment-session-id <SESSION_ID> \
  --payment-user-id test-user-123
```
クラスを使用して`PaymentManager`、HTTP 402 レスポンスを受け取ったときに支払いヘッダーを生成します。  

```
import uuid
from bedrock_agentcore.payments import PaymentManager

manager = PaymentManager(
    payment_manager_arn=PAYMENT_MANAGER_ARN,
    region_name="us-west-2"
)

# When you receive a 402 response, generate payment proof
payment_required_request = {
    "statusCode": 402,
    "headers": payment_required["headers"],
    "body": payment_required["body"],
}
payment_proof_headers = manager.generate_payment_header(
    user_id="test-user-123",
    payment_instrument_id=INSTRUMENT_ID,
    payment_session_id=SESSION_ID,
    payment_required_request=payment_required_request,
    client_token=str(uuid.uuid4()),
)
```
 `payment_proof_headers` には、支払い証明ヘッダーが含まれています。有料エンドポイントへのリクエストを再試行する場合は、このヘッダーを含めます。
x402 ペイロードを使用して`process-payment`直接 を呼び出します (自分で支払いオーケストレーションを処理する場合に使用されます）。  

```
aws bedrock-agentcore process-payment \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-session-id "$SESSION_ID" \
    --payment-instrument-id "$INSTRUMENT_ID" \
    --payment-type "CRYPTO_X402" \
    --payment-input '{
        "cryptoX402": {
            "version": "2",
            "payload": {
                "scheme": "exact",
                "network": "eip155:84532",
                "amount": "100000",
                "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                "payTo": "0xMERCHANT_ADDRESS",
                "maxTimeoutSeconds": 300,
                "extra": {"name": "USDC", "version": "2"}
            }
        }
    }' \
    --client-token "$(uuidgen)" \
    --region us-west-2
```
完全なリクエストとレスポンスのスキーマについては、 API リファレンスの[ProcessPayment](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_ProcessPayment.html)」を参照してください。

```
from strands import Agent
from strands_tools import http_request
from bedrock_agentcore.payments.integrations.config import AgentCorePaymentsPluginConfig
from bedrock_agentcore.payments.integrations.strands.plugin import AgentCorePaymentsPlugin

config = AgentCorePaymentsPluginConfig(
    payment_manager_arn=PAYMENT_MANAGER_ARN,
    user_id="test-user-123",
    payment_instrument_id=INSTRUMENT_ID,
    payment_session_id=SESSION_ID,
    region="us-west-2",
)

plugin = AgentCorePaymentsPlugin(config=config)
agent = Agent(
    system_prompt="You are a helpful assistant that can access paid APIs.",
    tools=[http_request],
    plugins=[plugin],
)

# The agent handles 402 responses automatically
response = agent("Access the premium endpoint at https://example-x402-merchant.com/paid-api")
print(response)
```
基盤となる API コールの完全なリクエストとレスポンスのスキーマについては、 API リファレンスの[ProcessPayment](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_ProcessPayment.html)」を参照してください。

### 支払いを確認する
<a name="payments-getting-started-verify"></a>

エージェントが支払いを処理したら、セッションをチェックしてトランザクションが記録されたことを確認します。

**Example**  

```
session = manager.get_payment_session(
    user_id="test-user-123",
    payment_session_id=SESSION_ID
)
print(f"Status: {session['status']}, Remaining: {session['remainingAmount']}")
```
計測バランスを確認することもできます。  

```
balance = manager.get_payment_instrument_balance(
    user_id="test-user-123",
    payment_instrument_id=INSTRUMENT_ID
)
print(f"Remaining balance: {balance['amount']} {balance['currency']}")
```

```
aws bedrock-agentcore get-payment-session \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-session-id "$SESSION_ID" \
    --region us-west-2

aws bedrock-agentcore get-payment-instrument-balance \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-instrument-id "$INSTRUMENT_ID" \
    --region us-west-2
```

```
session_status = dp_client.get_payment_session(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    paymentSessionId=SESSION_ID
)
print(f"Session status: {session_status['status']}")
print(f"Amount spent: {session_status.get('spentAmount', '0.00')} USD")
```
計測バランスを確認することもできます。  

```
balance = dp_client.get_payment_instrument_balance(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    paymentInstrumentId=INSTRUMENT_ID
)
print(f"Remaining balance: {balance['amount']} {balance['currency']}")
```

## トラブルシューティング
<a name="payments-getting-started-troubleshooting"></a>

スキルベースと手動の両方の設定パスには、次の問題が適用されます。


| 問題 | ソリューション | 
| --- | --- | 
| Payment Manager が CREATING でスタックする | 最大 2 分待ちます。CREATE\_FAILED に移動する場合は、サービスロールの ARN とアクセス許可が正しいことを確認します。 | 
| PaymentInstrument not active」 | エンドユーザーは、エージェントが取引する前に、ウォレットに資金を提供し、リダイレクト URL を介して署名アクセス許可を付与する必要があります。 | 
| 「セッションの有効期限切れまたは予算超過」 | 有効期限が長いか、使用制限がより高い新しい支払いセッションを作成します。 | 
| CredentialProvider not found」 | 認証情報プロバイダーの ARN がステップ 2 で作成したものと一致していることを確認します。リージョンがすべての呼び出しで一貫していることを確認します。 | 
| ProcessPayment が FAILED を返す | ウォレットに取引金額とガス料金に十分な USDC 残高があることを確認します。 | 

## クリーンアップ
<a name="payments-getting-started-cleanup"></a>

このチュートリアルで作成したリソースを削除します。

**Example**  

```
agentcore remove payment-connector --manager my-payment-manager --name my-coinbase-connector --yes
agentcore remove payment-manager --name my-payment-manager --yes
agentcore deploy
```
`remove` コマンドはローカル設定を更新します。フォローアップにより、アカウントの支払いインフラストラクチャが`deploy`破棄されます。

```
from bedrock_agentcore.payments import PaymentClient

payment_client = PaymentClient(region_name="us-west-2")

payment_client.delete_payment_manager(
    payment_manager_id="<paymentManagerId>"
)

print("Payment Manager deleted.")
```

```
aws bedrock-agentcore delete-payment-instrument \
    --payment-manager-arn "$PAYMENT_MANAGER_ARN" \
    --payment-instrument-id "$INSTRUMENT_ID" \
    --region us-west-2

aws bedrock-agentcore-control delete-payment-connector \
    --payment-manager-id "$PAYMENT_MANAGER_ID" \
    --payment-connector-id "$PAYMENT_CONNECTOR_ID" \
    --region us-west-2

aws bedrock-agentcore-control delete-payment-manager \
    --payment-manager-id "$PAYMENT_MANAGER_ID" \
    --region us-west-2
```

```
# Delete payment instrument
dp_client.delete_payment_instrument(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    paymentInstrumentId=INSTRUMENT_ID
)

# Delete payment connector
client.delete_payment_connector(
    paymentManagerArn=PAYMENT_MANAGER_ARN,
    paymentConnectorId=PAYMENT_CONNECTOR_ID
)

# Delete payment manager
client.delete_payment_manager(
    paymentManagerArn=PAYMENT_MANAGER_ARN
)

print("All payment resources deleted.")
```

## 構築したもの
<a name="payments-getting-started-what-youve-built"></a>

このチュートリアルでは、以下を作成しました。
+  **PaymentCredentialProvider** — AgentCore Identity に保存されている支払いプロバイダー認証情報
+  **PaymentManager** — 支払いオペレーションを調整する最上位のリソース
+  **PaymentConnector** — マネージャーと外部支払いプロバイダーの統合
+  **PaymentInstrument** — エンドユーザーが資金を提供し、承認した埋め込み暗号ウォレット
+  **PaymentSession** — 時間制限付き、予算制限付きの支払いコンテキスト
+  **ストランドエージェント** — x402 支払いを自動的に処理する AI エージェント

## 次の手順
<a name="payments-getting-started-next-steps"></a>
+  [Coinbase x402 Bazear に接続](payments-connect-bazaar.md)して、10,000 以上の有料 MCP ツールを検出します。
+  [Browser Tool と統合](payments-browser.md)して、有料ウェブサイトにアクセスします。
+  CloudWatch で支払いオペレーションをモニタリングする[オブザーバビリティを有効にします](payments-observability.md)。
+  [IAM ロールを確認して](payments-iam-roles.md)、本番稼働用の最小特権アクセスを設定します。