Cree un administrador de pagos Estados del ciclo de vida Obtenga un administrador de pagos Enumere los administradores de pagos Eliminar un administrador de pagos Siguientes pasos

Cree un administrador de pagos y un conector

Un administrador de pagos es el recurso de nivel superior que coordina las operaciones de pago de su AWS cuenta. Al crear un administrador de pagos, se especifica un tipo de autorizador y una función de IAM, y el servicio proporciona la identidad de carga de trabajo correspondiente en Identity. AgentCore

Esta guía explica cómo crear un administrador de pagos y cómo adjuntar un conector de pago mediante la consola de AWS administración o el SDK. AWS Para ver los esquemas completos de solicitud y respuesta, consulte CreatePaymentManagery CreatePaymentConnectoren la referencia de la API.

sugerencia

Puedes automatizar los pasos de esta página con la habilidad de AgentCore pagos del kit de herramientas para AWS agentes. La habilidad forma parte del complemento aws-agents y permite a un agente de codificación de IA crear su administrador de pagos, conector, proveedor de credenciales, instrumento de pago y sesión mediante la agentcore CLI, y añadir una herramienta de pago x402 a su agente. Para obtener más información, consulte la guía de inicio rápido y el kit de herramientas para agentes en.AWS GitHub

Antes de comenzar, asegúrese de que dispone de lo siguiente:

Se han completado los requisitos previos (cuenta, credenciales, claves de proveedor).
Configure las funciones de IAM requeridas (función de administrador y función de servicio).

Cree un administrador de pagos

ejemplo

Console

Paso 1: Abre la página de pagos

Abre la AgentCore consola Amazon Bedrock.
En el panel de navegación, en Crear, selecciona Pagos.
En la sección Gestores de pagos, selecciona Crear gestor de pagos.

Paso 2: Configurar los detalles del administrador de pagos

En Nombre, introduce un nombre para tu gestor de pagos. El nombre debe comenzar por una letra. Los caracteres válidos sona–z,A–Z,0–9. El nombre puede tener hasta 48 caracteres.
(Opcional) Selecciona Descripción para ampliar la sección y, a continuación, introduce una descripción que ayude a identificar a este gestor de pagos.

Paso 3: Configurar los permisos

La sección de permisos especifica los permisos de este administrador de pagos y los AWS recursos a los que puede acceder el pago.

Para los permisos de IAM, elige una de las siguientes opciones:

Cree y utilice un nuevo rol de servicio: Amazon Bedrock AgentCore Payments crea un nuevo rol de servicio en su nombre. Se genera automáticamente un nombre de función de servicio predeterminado. Para obtener más información, consulte Permisos de roles de servicios.
Use un rol de servicio existente: use un rol de servicio que ya haya creado. Si elige esta opción, seleccione un rol de la lista desplegable.

Paso 4: Configurar la autorización entrante

La autorización entrante controla quién puede acceder a este administrador de pagos. En la sección Autenticación entrante, para el tipo de autenticación entrante, elige una de las siguientes opciones:

Para usar la autorización de IAM:

Elija Usar nombre de usuario de IAM. Utiliza el nombre de usuario de IAM que utilizaste para iniciar sesión en la AWS consola.

Para usar la autorización de JWT con Amazon Cognito:

Elija Usar tokens web JSON (JWT).
Para configurar el esquema JWT, elija Creación rápida de configuraciones con Cognito (recomendado). Amazon Bedrock AgentCore Payments crea las configuraciones de autorización entrante en su nombre utilizando Amazon Cognito como proveedor de identidad. No se necesita configuración adicional.

Para usar la autorización de JWT con un proveedor de identidad existente:

Elija Usar tokens web JSON (JWT).
Para configurar el esquema JWT, elija Usar las configuraciones de proveedores de identidad existentes. Esta opción te permite incorporar las configuraciones de autorización entrante existentes desde cualquier proveedor de identidad para habilitar OAuth 2.0.
En Discovery URL, introduce la URL de descubrimiento de tu proveedor de identidad (por ejemplo, Okta o Cognito), que normalmente se encuentra en la documentación de ese proveedor. Esto permite a su agente o herramienta obtener la configuración de inicio de sesión, el token de recursos intermedios y la configuración de verificación. Por ejemplo, https://accounts.cognito.com/.well-known/openid-configuration.
En Audiencias permitidas, introduzca los ID de cliente que estén registrados con los proveedores de identidad o cualquier cadena arbitraria de la afirmación de audiencia de JWT que el autorizador deba verificar. Seleccione + Añadir audiencia para añadir audiencias adicionales.
En Clientes permitidos, introduzca los ID de cliente que estén registrados con los proveedores de identidad o cualquier cadena arbitraria de la afirmación de audiencia de JWT que el autorizador deba verificar. Seleccione + Añadir cliente para añadir clientes adicionales.
En Ámbitos permitidos, introduzca los ámbitos necesarios. El acceso solo está permitido si el token contiene al menos uno de los ámbitos obligatorios configurados aquí. Seleccione + Añadir ámbito para añadir ámbitos adicionales.
(Opcional) Para las notificaciones personalizadas, defina reglas que hagan coincidir las afirmaciones específicas del token entrante con los valores predefinidos. Para cada regla, especifique el nombre de la reclamación, el tipo de cadena, el operador y el valor. Seleccione + Añadir reclamación para añadir reclamaciones adicionales.

Paso 5: Agrega un conector de pago (opcional)

Los conectores de pago almacenan las credenciales y la configuración necesarias para conectarse con los proveedores de servicios de pago. Añadir un conector durante la creación es opcional, pero es necesario para que el servicio procese los pagos.

En la sección Conector de pagos: nuevo conector, en Nombre, introduzca un nombre para el conector. Los caracteres válidos son a–zA–Z,0–9, y _ (subrayado). El nombre puede tener hasta 48 caracteres.
(Opcional) Elija Descripción para expandir la sección y, a continuación, introduzca una descripción para el conector.
En la sección Añadir autenticación saliente, si quiere reutilizar un proveedor de credenciales de pago creado anteriormente en AgentCore Identity, seleccione una autenticación saliente existente en el menú desplegable o elija crear una nueva para crear un nuevo proveedor de credenciales de pago. Si decides crear una nueva, consulta Crear una nueva autenticación saliente.
(Opcional) Para añadir conectores adicionales, selecciona + Añadir conector y repite los pasos anteriores.

Cree una nueva autenticación de salida

Al elegir crear una nueva en la sección de autenticación saliente del conector, se abre un panel en el que puede configurar un nuevo proveedor de credenciales de pago.

En Nombre, introduzca un nombre para la autenticación saliente. Los caracteres válidos sona–z, A–Z0–9, _ (guión bajo) y - (guión).
En Proveedor, selecciona un proveedor de pagos en el menú desplegable. Los proveedores disponibles son Coinbase y Stripe (Privy).

Si elige Coinbase, complete los siguientes campos en Configuraciones de proveedores de pagos:

Para el ID de la clave de API, introduzca el identificador único de las credenciales de su cuenta de Coinbase CDP.
Para el secreto de la clave de API, introduzca la clave privada utilizada para autenticar y firmar las solicitudes a Coinbase CDP.
En Wallet secret, introduce la clave privada asimétrica que se utiliza para autenticar las operaciones confidenciales de escritura de carteras.

Si eliges Stripe (Privy), rellena los siguientes campos en la sección Configuración del proveedor de pagos:

En el caso del ID de aplicación, introduce el identificador único de las credenciales de tu cuenta privada.
En Secreto de aplicación, introduce la clave privada utilizada para autenticar y firmar las solicitudes a la aplicación Privy.
En el campo ID de autorización, introduzca el identificador único de la entidad de autorización.
En Clave privada de autorización, introduzca la clave privada utilizada para firmar las solicitudes de autorización.

Después de completar la configuración del proveedor, elija Agregar autenticación saliente.

Paso 6: Crea el administrador de pagos

Revise la configuración y, a continuación, seleccione Crear administrador de pagos.

Tras seleccionar Crear gestor de pagos, la consola accederá a la página de detalles del gestor de pagos. Un aviso de éxito confirma que se ha creado el gestor de pagos y proporciona los siguientes pasos:

Configure el instrumento y la sesión de pago y, si lo desea, especifique el presupuesto.
Integre el gestor de pagos en su estructura de agentes.
Descubra las herramientas y puntos finales de pago de MCP.
Habilite las entregas y los seguimientos de registros para ver las métricas en el panel de observabilidad.

La página de detalles del gestor de pagos incluye secciones sobre los conectores de pagos, las plantillas de códigos de integración, la autenticación entrante, las métricas de observabilidad y la configuración de envíos y seguimiento de registros.

AgentCore CLI

La AgentCore CLI crea el proveedor de credenciales, el administrador de pagos y el conector de pago juntos desde el directorio del proyecto. Requiere CLI v0.19.0 o posterior.

Asistente interactivo:


agentcore add payment-manager

El asistente solicita el nombre del administrador, el patrón, la opción de pago automático y el límite de gasto y, opcionalmente, explica cómo agregar un conector con las credenciales del proveedor.

Non-interactive (Coinbase CDP):


agentcore add payment-manager \
  --name MyPaymentManager \
  --auto-payment \
  --default-spend-limit 10.00

agentcore add payment-connector \
  --manager MyPaymentManager \
  --name CoinbaseConnector \
  --provider CoinbaseCDP \
  --api-key-id <YOUR_API_KEY_ID> \
  --api-key-secret <YOUR_API_KEY_SECRET> \
  --wallet-secret <YOUR_WALLET_SECRET>

agentcore deploy

Non-interactive (Stripe/Privy):


agentcore add payment-manager \
  --name MyPaymentManager \
  --auto-payment \
  --default-spend-limit 10.00

agentcore add payment-connector \
  --manager MyPaymentManager \
  --name StripePrivyConnector \
  --provider StripePrivy \
  --app-id <YOUR_APP_ID> \
  --app-secret <YOUR_APP_SECRET> \
  --authorization-id <YOUR_AUTHORIZATION_ID> \
  --authorization-private-key <YOUR_PRIVATE_KEY_BASE64>

agentcore deploy

Running agentcore deploy aprovisiona las funciones de IAM, almacena las credenciales en AgentCore Identity y crea el administrador de pagos y el conector.

AgentCore SDK

El AgentCore SDK proporciona un método práctico create_payment_manager_with_connector que permite crear el administrador de pagos, el proveedor de credenciales y el conector en una sola llamada.

Coinbase CDP con autorización de IAM:


from bedrock_agentcore.payments import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="MyPaymentManager",
    payment_manager_description="Payment manager for my agent.",
    authorizer_type="AWS_IAM",
    role_arn="arn:aws:iam::123456789012:role/MyPaymentRole",
    payment_connector_config={
        "name": "CoinbaseConnector",
        "description": "Coinbase CDP connector",
        "payment_credential_provider_config": {
            "name": "MyCoinbaseProvider",
            "credential_provider_vendor": "CoinbaseCDP",
            "credentials": {
                "api_key_id": "your-api-key-id",
                "api_key_secret": "your-api-key-secret",
                "wallet_secret": "your-wallet-secret",
            },
        },
    },
    wait_for_ready=True,
    max_wait=300,
    poll_interval=5,
)

payment_manager = response.get("paymentManager", {})
payment_connector = response.get("paymentConnector", {})
credential_provider = response.get("credentialProvider", {})

payment_manager_arn = payment_manager.get("paymentManagerArn")
payment_connector_id = payment_connector.get("paymentConnectorId")

print(f"Payment Manager ARN: {payment_manager_arn}")
print(f"Connector ID: {payment_connector_id}")

Coinbase CDP con autorización JWT:


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="CoinbasePaymentManagerJWT",
    payment_manager_description="Coinbase Payment Manager (JWT auth)",
    authorizer_type="CUSTOM_JWT",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "coinbase-connector-jwt",
        "description": "Coinbase Connector (JWT)",
        "payment_credential_provider_config": {
            "name": "my-coinbase-provider-jwt",
            "credential_provider_vendor": "CoinbaseCDP",
            "credentials": {
                "api_key_id": "your-api-key-id",
                "api_key_secret": "your-api-key-secret",
                "wallet_secret": "your-wallet-secret",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

Stripe (Privy) con autorización de IAM:


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="StripePaymentManager",
    payment_manager_description="Stripe + Privy Payment Manager (IAM auth)",
    authorizer_type="AWS_IAM",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "stripe-privy-connector",
        "description": "Stripe + Privy Connector",
        "payment_credential_provider_config": {
            "name": "my-stripe-privy-provider",
            "credential_provider_vendor": "StripePrivy",
            "credentials": {
                "app_id": "your-privy-app-id",
                "app_secret": "your-privy-app-secret",
                "authorization_private_key": "your-authorization-private-key",
                "authorization_id": "your-authorization-id",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

Stripe (Privy) con autorización de JWT:


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="StripePaymentManagerJWT",
    payment_manager_description="Stripe + Privy Payment Manager (JWT auth)",
    authorizer_type="CUSTOM_JWT",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "stripe-privy-connector-jwt",
        "description": "Stripe + Privy Connector (JWT)",
        "payment_credential_provider_config": {
            "name": "my-stripe-privy-provider-jwt",
            "credential_provider_vendor": "StripePrivy",
            "credentials": {
                "app_id": "your-privy-app-id",
                "app_secret": "your-privy-app-secret",
                "authorization_private_key": "your-authorization-private-key",
                "authorization_id": "your-authorization-id",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

AWS CLI

Cree un administrador de pagos con autorización de IAM:


aws bedrock-agentcore-control create-payment-manager \
  --name "MyPaymentManager" \
  --authorizer-type AWS_IAM \
  --role-arn "arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole" \
  --region us-east-1

Cree un administrador de pagos con la autorización de JWT:


aws bedrock-agentcore-control create-payment-manager \
  --name "MyPaymentManager" \
  --authorizer-type CUSTOM_JWT \
  --role-arn "arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole" \
  --custom-jwt-authorizer-configuration '{
    "discoveryUrl": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE/.well-known/openid-configuration",
    "allowedAudience": ["your-client-id"],
    "allowedClients": ["your-client-id"]
  }' \
  --region us-east-1

El estado de administrador de pagos comienza READY cuando se completa el aprovisionamiento CREATING y pasa a ese estado.

Cuando el administrador de pagos esté listo, cree un proveedor de credenciales de pago:

El siguiente ejemplo crea un proveedor de credenciales de pago para Coinbase CDP:


aws bedrock-agentcore-control create-payment-credential-provider \
  --name "coinbase-provider" \
  --credential-provider-vendor CoinbaseCDP \
  --provider-configuration-input '{
    "coinbaseCdpConfiguration": {
      "apiKeyId": "your-coinbase-api-key-id",
      "apiKeySecret": "your-coinbase-api-key-secret",
      "walletSecret": "your-coinbase-wallet-secret"
    }
  }' \
  --region us-east-1

El siguiente ejemplo crea un proveedor de credenciales de pago para Stripe Privy:


aws bedrock-agentcore-control create-payment-credential-provider \
  --name "stripe-privy-provider" \
  --credential-provider-vendor StripePrivy \
  --provider-configuration-input '{
    "stripePrivyConfiguration": {
      "appId": "your-stripe-privy-app-id",
      "appSecret": "your-stripe-privy-app-secret",
      "authorizationPrivateKey": "your-stripe-privy-authorization-private-key",
      "authorizationId": "your-stripe-privy-authorization-id"
    }
  }' \
  --region us-east-1

Cuando el proveedor de credenciales esté listo, crea un conector:


aws bedrock-agentcore-control create-payment-connector \
  --payment-manager-id <paymentManagerId> \
  --name "CoinbaseConnector" \
  --type CoinbaseCDP \
  --credential-provider-configurations '[{
    "coinbaseCDP": {
      "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-cdp-provider"
    }
  }]' \
  --region us-east-1

AWS SDK

Cree un administrador de pagos con autorización de IAM:


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

# Create PaymentManager with IAM authorization
payment_manager = client.create_payment_manager(
    name="MyPaymentManager",
    authorizerType="AWS_IAM",
    roleArn="arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole"
)

print(f"Payment Manager ID: {payment_manager['paymentManagerId']}")

Cree un administrador de pagos con la autorización de JWT:


payment_manager = client.create_payment_manager(
    name="MyPaymentManager",
    authorizerType="CUSTOM_JWT",
    roleArn="arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole",
    customJWTAuthorizerConfiguration={
        "discoveryUrl": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE/.well-known/openid-configuration",
        "allowedAudience": ["your-client-id"],
        "allowedClients": ["your-client-id"],
        "allowedScopes": ["payments:write"],
        "customClaims": [
            {
                "claimName": "tenant_id",
                "claimValue": "your-unique-tenant-id",
                "operation": "EQUALS"
            }
        ]
    }
)

Cuando el administrador de pagos alcance el READY estado, cree un proveedor de credenciales de pago:

El siguiente ejemplo configura un proveedor para Coinbase CDP:


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

coinbase_provider = client.create_payment_credential_provider(
    name="coinbase-provider",
    credentialProviderVendor="CoinbaseCDP",
    providerConfigurationInput={
        "coinbaseCdpConfiguration": {
            "apiKeyId": "your-coinbase-api-key-id",
            "apiKeySecret": "your-coinbase-api-key-secret",
            "walletSecret": "your-coinbase-wallet-secret"
        }
    }
)

El siguiente ejemplo configura un proveedor para Stripe Privy:


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

stripe_privy_provider = client.create_payment_credential_provider(
    name="stripe-privy-provider",
    credentialProviderVendor="StripePrivy",
    providerConfigurationInput={
        "stripePrivyConfiguration": {
            "appId": "your-stripe-privy-app-id",
            "appSecret": "your-stripe-privy-app-secret",
            "authorizationPrivateKey": "your-stripe-privy-authorization-private-key",
            "authorizationId": "your-stripe-privy-authorization-id"
        }
    }
)

Tras crear el proveedor de credenciales de pago, cree un conector:


# Create PaymentConnector for Coinbase CDP
payment_connector = client.create_payment_connector(
    paymentManagerId=payment_manager["paymentManagerId"],
    name="CoinbaseConnector",
    type="CoinbaseCDP",
    credentialProviderConfigurations=[
        {
            "coinbaseCDP": {
                "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-cdp-provider"
            }
        }
    ]
)

print(f"Connector ID: {payment_connector['paymentConnectorId']}")

Para Stripe (Privy), usa la variante de stripePrivy configuración:


# Create PaymentConnector for Stripe (Privy)
payment_connector = client.create_payment_connector(
    paymentManagerId=payment_manager["paymentManagerId"],
    name="StripePrivyConnector",
    type="StripePrivy",
    credentialProviderConfigurations=[
        {
            "stripePrivy": {
                "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-privy-provider"
            }
        }
    ]
)

Estados del ciclo de vida

Tras la creación, el gestor de pagos pasa por los siguientes estados:

Estado	Description (Descripción)
`CREATING`	Estado inicial durante el aprovisionamiento.
`READY`	Payment Manager está operativo y acepta configuraciones de conectores.
`UPDATING`	Se está aplicando un cambio de configuración.
`CREATE_FAILED`	Fallo de aprovisionamiento.
`UPDATE_FAILED`	Fallo en la operación de actualización.

Obtenga un administrador de pagos

ejemplo

Enumere los administradores de pagos

ejemplo

Eliminar un administrador de pagos

ejemplo

Siguientes pasos

Tras crear tu gestor de pagos, podrás:

Configurar los instrumentos y las sesiones de pago: configure los instrumentos y las sesiones de pago para empezar a procesar las transacciones. Consulte Crear un instrumento de pago.
Intégrelo con el marco de su agente: utilice las plantillas de códigos de integración para conectar el gestor de pagos con el flujo de trabajo de su agente. Consulte Procesamiento de pagos.
Descubra las herramientas y puntos de enlace de pago de MCP: Conéctese a servidores de MCP listos para usar con puntos de enlace de pago por uso o traiga sus propios puntos de enlace comerciales. Visite AgentCore Coinbase Bazaar a través de Gateway.
Habilite la observabilidad: configure las entregas y el seguimiento de los registros para monitorear las sesiones, las invocaciones a las API, las transacciones y las tasas de error. Consulte Observabilidad.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Roles de IAM

Procesamiento de pagos