Utilisation de la compétence AgentCore Paiements Utilisation de la CLI, du SDK ou de Boto3 Résolution des problèmes Nettoyage Ce que vous avez construit Étapes suivantes

AgentCore démarrage rapide des paiements

Ce didacticiel vous explique comment configurer AgentCore les paiements et traiter votre première microtransaction. À la fin, votre agent paiera pour une ressource en utilisant le protocole x402 sur un réseau de test.

Vous pouvez configurer les paiements de deux manières :

Utilisation de la compétence AgentCore Paiements — Une expérience de configuration automatisée qui fournit toutes les ressources par le biais d'une conversation guidée avec des agents de codage basés sur l'IA tels que Kiro, Claude Code ou Codex. La compétence gère les commandes CLI, les scripts du SDK et le câblage du framework à votre place.
Utilisation de la CLI, du SDK ou de Boto3 : configuration manuelle étape par étape à l'aide de la CLI, du AWS SDK ou de la AgentCore CLI directement. AWS

Utilisation de la compétence AgentCore Paiements

La compétence AgentCore Paiements automatise l'ensemble du processus de configuration grâce à une expérience guidée interactive. Il fournit les ressources suivantes :

PaymentCredentialProvider— Stocke les informations d'identification du fournisseur de paiement dans AgentCore Identity.
Payment Manager : ressource de haut niveau qui coordonne les opérations de paiement.
Connecteur de paiement : relie le gestionnaire à vos informations d'identification via la AgentCore CLI.
Instrument de paiement — Un portefeuille crypté que votre agent utilise pour payer les commerçants au nom d'un utilisateur.
Session de paiement — Un contexte limité dans le temps avec des limites de dépenses.

La compétence transfère également les paiements à votre agent à l'aide d'un outil indépendant du framework, de sorte qu'elle fonctionne avec Strands, le SDK LangGraph OpenAI Agents ou n'importe quel framework Python.

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

AWS Compte avec informations d'identification configurées (aws configure)
AWS Région dans laquelle AgentCore les paiements sont disponibles : us-east-1, us-west-2, eu-central-1 ou ap-southeast-2. Voir AWS Régions prises en charge.
Node.js Plus de 20 personnes installées (la compétence installe automatiquement la AgentCore CLI)
Un agent qui accède à un point de terminaison payant : cette compétence permet à votre agent de payer pour des API protégées par x402. Pour les tests, vous pouvez utiliser le point de terminaison https://sandbox.node4all.com/v1/x402-test sandbox.
L'Agent Toolkit pour AWS aws-agents le plugin installé dans votre agent de codage AI :
Exemple
Claude Code

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

Codex

Le plugin est découvert automatiquement à partir du manifeste du marché. Pour ajouter le site de vente, exécutez la commande suivante :

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

Invoquez la compétence

La compétence de paiement fait partie de la agents-build compétence de la boîte à outils des agents pour AWS. Pour le déclencher, décrivez votre intention dans votre agent de codage AI. Par exemple :

« Ajouter des paiements à mon agent en utilisant le aws-agents plugin agents-build skill in »
« Configurer des microtransactions pour mon agent à l'aide du aws-agents plugin agents-build skill in »
« Je dois gérer 402 réponses de paiement requises à l'aide du aws-agents plugin agents-build skill in »
« Téléphonez à mon agent pour qu'il paie pour des API protégées par x402 en utilisant agents-build Skill in Plugin » aws-agents

La compétence détecte les intentions liées au paiement et charge automatiquement le flux de travail des paiements.

À quoi sert la compétence

La compétence exécute un processus automatisé qui approvisionne votre infrastructure de paiement de bout en bout. La compétence exécute automatiquement la plupart des étapes et s'arrête deux fois pour que vous saisissiez :

Vérifie ou installe la AgentCore CLI et configure le projet
Crée le gestionnaire de paiement
Pauses — Vous courez agentcore add payment-connector pour saisir les secrets de votre fournisseur (informations d'identification Coinbase CDP ou Stripe Privy)
Déploie des ressources sur votre AWS compte () agentcore deploy -y
Transfère un outil de paiement indépendant du framework (x402_payment_tool.py) à votre agent
Crée un portefeuille (instrument) par utilisateur et une session limitée au budget via le SDK
Pauses — Vous autorisez le portefeuille (délégation) et vous le financez avec testnet USDC depuis le site Web de Circle Faucet
Définit les variables d'environnement et exécute un paiement test sur un point de terminaison payant

Avant d'exécuter la commande connector, obtenez les informations d'identification de votre fournisseur :

Coinbase CDP — ID de clé d'API, secret de clé d'API et secret de portefeuille provenant du site Web de Coinbase Developer Platform (avec signature déléguée activée).
Stripe Privy — ID d'application, secret de l'application, ID d'autorisation et clé privée d'autorisation depuis le site Web du tableau de bord Privy.

Une exécution réussie indique que l'agent appellex402_fetch, détecte un paiement402, règle un paiement via le AgentCore SDK, puis réessaie de revenir 200 avec du contenu payant.

Utilisation de la CLI, du SDK ou de Boto3

Cette section explique chaque étape manuellement à l'aide de la AgentCore CLI, de l'interface de AWS ligne de commande ou du AWS SDK (Boto3).

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

AWS Compte avec informations d'identification configurées (aws configure)
Python 3.10+ installé
AWS Région dans laquelle AgentCore les paiements sont disponibles : us-east-1, us-west-2, eu-central-1 ou ap-southeast-2. Voir AWS Régions prises en charge.

Installez les packages requis :


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

Vérifiez que vos informations d'identification sont configurées :


aws sts get-caller-identity

Astuce

Si la AgentCore CLI v0.19.0 ou version ultérieure est installée, vous pouvez utiliser les commandes de la CLI comme alternative au SDK aux étapes 2, 3, 5 et 6. Chaque étape ci-dessous montre les deux options.

Étape 1 : obtenir les informations d'identification du fournisseur de services de paiement

AgentCore payments se connecte à un fournisseur de paiement externe pour les opérations de portefeuille. Vous avez besoin des informations d'identification de l'un des fournisseurs pris en charge avant de continuer.

Exemple

Coinbase CDP

Connectez-vous à la plateforme de développement Coinbase et créez ou sélectionnez un projet.
Générez une clé d'API et notez l'ID de la clé d'API, le secret de la clé d'API et le secret du portefeuille.
Sous Projet > Portefeuilles > Non-custodial Portefeuille > Sécurité, activez la signature déléguée.

Vous utiliserez ces trois valeurs à l'étape suivante :

Informations d'identification	Description
`API Key ID`	Identifiant public pour votre projet CDP
`API Key Secret`	Secret privé pour la signature des demandes d'API
`Wallet Secret`	Secret pour les opérations de portefeuille cryptographique (dérivation d'adresses, signature de transactions)

Privy

Créez une application Privy dédiée sur dashboard.privy.io. Ne réutilisez pas les applications qui servent à d'autres fins.
Copiez l'identifiant et le secret de l'application depuis les paramètres de votre application.
Accédez à Wallet Infrastructure > Autorisation et choisissez New Key pour générer une paire de P-256 clés.

Vous utiliserez ces quatre valeurs à l'étape suivante :

Informations d'identification	Description
`App ID`	L'identifiant de votre application Privy
`App Secret`	Secret de l'authentification de base de serveur à serveur
`Authorization ID`	Identifiant de clé publique issu de la paire de P-256 clés
`Authorization Private Key`	Clé privée issue de la paire de P-256 clés

Pour plus de détails, y compris les meilleures pratiques en matière de sécurité et la rotation des identifiants, consultez la section Conditions préalables.

Étape 2 : Stocker les informations d'identification dans AgentCore Identity

Conservez les informations d'identification de votre fournisseur de services de paiement sous forme de PaymentCredentialProvider. Cela permet de conserver les AWS secrets dans Secrets Manager plutôt que dans le code de votre application.

Exemple

Pour le schéma complet de demande et de réponse, reportez-vous CreatePaymentCredentialProviderà la référence de l'API.

Alternative à la CLI : enregistrer les informations d'identification

Avec la AgentCore CLI, le stockage des informations d'identification se fait automatiquement lorsque vous ajoutez un connecteur de paiement (étape 3). Ignorez cette étape si vous prévoyez d'utiliser le chemin de la CLI.

Étape 3 : créer un gestionnaire de paiement et un connecteur

Un gestionnaire de paiement est la ressource de haut niveau qui coordonne les opérations de paiement. Un connecteur de paiement relie le gestionnaire aux informations d'identification de votre fournisseur de paiement. Avant de créer ces ressources, configurez les rôles IAM requis, comme décrit dans la section Rôles IAM pour AgentCore les paiements.

Exemple

Console

Pour une présentation complète de la console, y compris l'autorisation JWT et les réclamations personnalisées, voir Créer un gestionnaire et un connecteur de paiements.

Ouvrez la AgentCore console Amazon Bedrock.
Dans le volet de navigation, sous Build, sélectionnez Payments.
Choisissez Créer un gestionnaire de paiements.
Entrez le nom de votre gestionnaire de paiement.
Sous Autorisations, choisissez Créer et utiliser un nouveau rôle de service (ou sélectionnez un rôle existant).
Sous Inbound Auth, choisissez Utiliser le nom d'utilisateur IAM pour l'autorisation IAM.
(Facultatif) Dans la section Connecteur de paiement, choisissez un nom pour le connecteur et sélectionnez une authentification sortante existante ou créez-en une nouvelle en sélectionnant votre fournisseur (Coinbase ou Stripe Privy) et en saisissant vos informations d'identification.
Choisissez Créer un gestionnaire de paiements.

AgentCore CLI

La CLI crée le fournisseur d'informations d'identification, le gestionnaire de paiement et le connecteur de paiement en un seul flux. Depuis le répertoire de votre AgentCore projet, ajoutez un gestionnaire de paiement et un connecteur ensemble.

Assistant interactif :


agentcore add payment-manager

L'assistant demande le nom du responsable, le modèle (intercepteur), le mode de paiement automatique et la limite de dépenses par défaut. Il demande ensuite s'il faut ajouter un connecteur et passe en revue la sélection du fournisseur et la saisie des informations d'identification.

Non-interactive (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>

Non-interactive (Privé) :


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>

Après l'ajout, déployez pour approvisionner l'infrastructure de paiement :


agentcore deploy

L'étape de déploiement crée des rôles IAM, stocke les informations d'identification dans AgentCore Identity et approvisionne le gestionnaire de paiements et le connecteur. Vous verrez « Création d'une infrastructure de paiement... » dans le résultat.

AgentCore SDK

Le AgentCore SDK crée le gestionnaire de paiements, le fournisseur d'identifiants et le connecteur en un seul appel.


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}")

Pour Stripe Privy, remplacez le par credential_provider_vendor: "StripePrivy" et payment_credential_provider_config les informations d'identification Privy correspondantes.

AWS CLI

Créez le gestionnaire de paiements :


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

Une fois que le responsable a atteint READY le statut, créez un fournisseur d'informations d'identification et un connecteur. Voir Créer un gestionnaire de paiement et un connecteur pour le flux de travail complet de la AWS CLI.

AWS SDK

Créez d'abord le gestionnaire de paiement (le même pour les deux fournisseurs) :


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)

Créez ensuite le connecteur de paiement pour votre fournisseur :

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}")

Confidentialité :


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}")

Si vous n'avez pas de rôle de service, consultez la section Rôles IAM pour les AgentCore paiements pour savoir comment en créer un. La console peut également créer un rôle en votre nom. Pour les schémas complets de demande et de réponse, consultez CreatePaymentManageret CreatePaymentConnectordans la référence de l'API.

Étape 4 : Création d'un instrument de paiement

Un instrument de paiement est un portefeuille crypté intégré que votre agent utilise pour payer les commerçants au nom d'un utilisateur. Chaque instrument est associé à un réseau de blockchain spécifique.

Exemple

AgentCore SDK


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 CLI


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

Enregistrez le paymentInstrumentId et redirectUrl depuis la réponse.

AWS SDK


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}")

Pour le schéma complet de demande et de réponse, reportez-vous CreatePaymentInstrumentà la référence de l'API.

Financez le portefeuille et accordez des autorisations

Avant que l'agent puisse effectuer une transaction, l'utilisateur final doit approvisionner le portefeuille et accorder des autorisations de signature. Ouvrez le redirectUrl à partir de la réponse ci-dessus dans un navigateur. Depuis le hub de portefeuille, l'utilisateur peut :

Rechargez le portefeuille à l'aide d'un transfert crypté, d'une credit/debit carte, d'Apple Pay, de Google Pay ou d'ACH
Autoriser l'agent à signer des transactions en son nom

Pour un environnement de test, approvisionnez le portefeuille avec testnet USDC.

Après le financement, interrogez le statut de l'instrument jusqu'à ce qu'il devienne ACTIVE :

Exemple

Pour plus de détails sur les flux de financement par fournisseur, voir Financer le portefeuille.

Étape 5 : Création d'une session de paiement

Une session de paiement est un contexte limité dans le temps avec des limites de dépenses facultatives. Lorsque la session expire ou que le budget est épuisé, l'agent ne peut pas effectuer d'autres paiements au cours de cette session.

Exemple

AgentCore CLI

Lorsque vous utilisez la CLI, il n'est pas nécessaire de créer une session manuellement. Passez --auto-session à agentcore invoke et la CLI crée ou réutilise une session avec la limite de dépenses par défaut que vous avez configurée dans le gestionnaire de paiements.


agentcore invoke \
  --prompt "your prompt here" \
  --payment-instrument-id <INSTRUMENT_ID> \
  --auto-session \
  --payment-user-id test-user-123

Pour utiliser une session spécifique que vous avez créée via le SDK, passez --payment-session-id au lieu de--auto-session.

AgentCore SDK


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 CLI


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

AWS SDK


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)")

Pour le schéma complet de demande et de réponse, reportez-vous CreatePaymentSessionà la référence de l'API.

Étape 6 : Effectuer un paiement avec un agent Strands

Une fois toutes les ressources en place, créez un agent Strands qui gère automatiquement les paiements x402. Lorsque l'agent appelle un point de terminaison payant et reçoit une réponse HTTP 402, le plug-in de paiement signe la transaction et tente à nouveau la demande.

Exemple

AgentCore CLI

Invoquez votre agent déployé avec le contexte de paiement. La CLI transmet l'instrument de paiement et la session à l'agent au moment de l'exécution, et l'intercepteur x402 de l'agent gère le paiement automatiquement.


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

Pour transmettre une session explicite au lieu d'en créer une automatiquement :


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

AgentCore SDK

Utilisez la PaymentManager classe pour générer des en-têtes de paiement lorsque vous recevez une réponse 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_headerscontient l'en-tête de preuve de paiement. Incluez cet en-tête lorsque vous réessayez d'envoyer la demande au point de terminaison payant.

AWS CLI

Appelez process-payment directement avec une charge utile x402 (utilisée lorsque vous gérez vous-même l'orchestration des paiements) :


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

Pour le schéma complet de demande et de réponse, reportez-vous ProcessPaymentà la référence de l'API.

AWS SDK


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)

Pour le schéma complet de demande et de réponse de l'appel d'API sous-jacent, voir ProcessPaymentla référence d'API.

Vérifiez le paiement

Une fois que l'agent a traité un paiement, vérifiez la session pour confirmer que la transaction a été enregistrée :

Exemple

Résolution des problèmes

Les problèmes suivants concernent à la fois les parcours de configuration manuels et basés sur les compétences.

Problème	Solution
Le gestionnaire de paiement est bloqué dans CREATING	Patientez jusqu'à 2 minutes. S'il passe à CREATE_FAILED, vérifiez que l'ARN et les autorisations de votre rôle de service sont corrects.
« PaymentInstrument non actif »	L'utilisateur final doit approvisionner le portefeuille et accorder des autorisations de signature via l'URL de redirection avant que l'agent ne puisse effectuer une transaction.
« Session expirée ou budget dépassé »	Créez une nouvelle session de paiement avec une expiration plus longue ou une limite de dépenses plus élevée.
« CredentialProvider non trouvé »	Vérifiez que l'ARN du fournisseur d'informations d'identification correspond à celui que vous avez créé à l'étape 2. Assurez-vous que la région est cohérente pour tous les appels.
ProcessPayment Retours échoués	Vérifiez que le portefeuille dispose d'un solde USDC suffisant pour le montant de la transaction plus les frais d'essence.

Nettoyage

Supprimez les ressources que vous avez créées au cours de ce didacticiel :

Exemple

Ce que vous avez construit

Grâce à ce didacticiel, vous avez créé :

PaymentCredentialProvider— Informations d'identification du fournisseur de paiement stockées dans AgentCore Identity
PaymentManager— Top-level ressources coordonnant les opérations de paiement
PaymentConnector— Intégration entre votre responsable et le fournisseur de paiement externe
PaymentInstrument— Un portefeuille crypté intégré, financé et autorisé par l'utilisateur final
PaymentSession— Un contexte de paiement limité dans le temps et dans le budget
Strands Agent — Un agent d'IA qui gère automatiquement les paiements x402

Étapes suivantes

Connectez-vous à Coinbase x402 Bazaar pour découvrir plus de 10 000 outils MCP payants.
Intégrez l'outil de navigation pour accéder à des sites Web paywallés.
Activez l'observabilité pour surveiller les opérations de paiement dans. CloudWatch
Passez en revue les rôles IAM pour configurer l'accès avec le moindre privilège pour la production.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Concepts de base

Comment ça marche