Skip to main content

Agentic Commerce

Secure agentic commerce on your customers' terms

Your customers already send AI agents to shop, book and manage their accounts. Verify each agent, bind it to the customer who sent it, enforce that customer's limits on every call, and let the customer approve or revoke it.

Agentic commerce is buying, booking and account servicing done by AI agents on behalf of people. Selling to them safely starts with Know Your Agent (KYA): knowing which agent is at checkout, which customer sent it and what it may spend.

A customer asks an assistant to reorder household basics, book a flight under a budget or pay this month's bills, and the agent visits your site or API to do it. The customer is still your customer; they have sent an agent to act for them. Banks, fintechs, retailers and travel companies all have to decide how to accept these agents and keep control of the customer's account.

  • Know which agent is acting, and for which customer
  • Hold every agent to the limits its customer set
  • Let the customer approve risky purchases and revoke the agent
  • 393%

    Year-over-year growth in AI-driven traffic to US retail sites in Q1 2026. By March 2026 that traffic converted 42% better than non-AI traffic.

    Source: Adobe Analytics, 2026

  • $3–5T

    Global consumer spending projected to flow through AI agents by 2030.

    Source: McKinsey, projection for 2030

Where SecureAuth fits

Know Your Agent: three checks for AI agent verification in agentic commerce

Before an agent transacts, confirm that the request really comes from agent X, that your customer authorized X to do this, and that the payment itself is approved. The middle check is SecureAuth's job.

  1. Layer 1 · At your edge

    Is this request really from agent X, and is X a known operator?

    • HTTP Message Signatures (RFC 9421) and Web Bot Auth
    • Agent provider key directories
    • Visa Trusted Agent Protocol, Mastercard Agent Pay
    • Know Your Agent registries and allowlists

    Who answers it: Your CDN, WAF or bot management

  2. Layer 2 · The customer's authorization

    Did customer C authorize agent X to do this, within these limits?

    • Customer signs in on your site with a passkey or MFA
    • Consent naming the agent, its actions and limits such as spend
    • A short-lived token scoped by token exchange (RFC 8693), limits in authorization_details (RFC 9396), bound with DPoP or mTLS
    • Every call decided: allow, redact, throttle, ask the customer or deny
    • Approval on the customer's own device (CIBA), revocation from “My agents”

    Who answers it: SecureAuth

  3. Layer 3 · Payment

    Is the payment itself authorized?

    • AP2 mandates
    • Visa and Mastercard agentic tokens
    • Stripe Shared Payment Tokens, Agentic Commerce Protocol
    • Issuer authorization

    Who answers it: Your payment provider, network and issuer

Your edge recognizes signed agents, and your payment provider and the card networks authorize the money. Neither checks that this customer allowed the agent to take this action. SecureAuth does, using the customer's own sign-in, consent and limits, and leaves the money movement to the payment rails.

At checkout

Agent identity verification in agentic payment flows

Merchants verify an AI agent at checkout in two steps: prove which agent is calling, then prove which customer authorized it. Classify the actor first, then decide the transaction.

Agent-to-site authentication starts with the agent's own identity. Platform agents sign their requests with keys their provider publishes, network agents are vouched for by the card network that enrolled them, and agents your customers build connect as OAuth clients, identified by a published metadata document or registered through a protected endpoint. However it arrives, the agent then needs a token from your authorization server that names the customer, so the customer's identity always comes from a token your authorization server issued.

Who is at checkout, and how to treat each
Your customerHow you recognize itSigned in on your site with a passkey or MFATreatmentAllowYour normal customer policy and adaptive risk
The customer's agent, with a delegated tokenHow you recognize itA verified agent presenting a short-lived token that names the customer and is bound to the agent's keyTreatmentWithin the grantAllowed inside the customer's grant; every call decided
An identified agent, no delegationHow you recognize itA verified agent with no token from your authorization serverTreatmentAsk the customerPublic pages only, and sent to ask the customer for consent before it touches an account
Unidentified automationHow you recognize itNo verified identity and no tokenTreatmentBot policyYour bot policy, which tells people from automation; no account access
An impersonating agentHow you recognize itClaims to be a known agent, but its signature fails or its token isn't bound to its keyTreatmentDenyRefused and recorded

Unidentified automation stays with the bot detection that already protects your sign-in and registration. A verified agent without a delegation isn't a threat; it's a customer who hasn't said yes yet.

A customer's agent holds a bounded delegation, not a login

Treat it like a power of attorney: the agent is not the customer. It holds a bounded, revocable delegation from the customer, recorded in six parts and checked on every call.

  • Principal: the verified customer who grants the access
  • Agent: the one agent that receives it, with an identity of its own
  • Scope: for example read orders, add to cart and check out
  • Limits: per-order and monthly spend caps, merchants or categories, a time window
  • Purpose: what the access is for, such as a weekly grocery order
  • Lifecycle: an expiry date, and revocation by the customer at any time

The agent gets its own identity, so you can scope, audit and revoke it without touching the customer's sign-in. For how agent identity works across employees, autonomous jobs and customers, see AI agent identity and authorization.

Every call

Secure agentic transactions with a decision on every call

A token issued at consent isn't the end of the check. Agent Authority decides each call the agent makes against the customer's grant and live risk, with one of five outcomes.

The five decisions, applied to agentic commerce
AllowWhen it appliesInside the customer's grant, and normal for this customerAt checkoutReorder groceries under the $150 cap at a store the customer allowed
RedactWhen it appliesThe call may proceed, but the agent doesn't need everything in the responseAt checkoutOrder history returned with card numbers and other personal data removed
ThrottleWhen it appliesThe agent calls faster than its limits allowAt checkoutAn agent polling prices or retrying checkout is slowed to its rate limit
Ask a person (CIBA)When it appliesOutside the grant, or the transaction value, velocity or behavior looks riskyAt checkoutOver the spend cap, a new merchant or payee, a new shipping address: the customer approves on their own device
DenyWhen it appliesAn action you keep for the customer alone, or an agent that isn't who it claimsAt checkoutChange the password, email or payment method; a revoked agent's next call

Signals in each decision

  • Fit with the customer's grant
  • Transaction value against the caps
  • Velocity of the agent's calls
  • Drift from the customer's usual pattern
  • The customer's own account risk
  • Anomalies against the agent's baseline

No credentials in the agent's hands

Agents never hold the downstream credentials for your APIs. On an allowed call, the credential broker in Agent Authority swaps the agent's scoped token for the downstream credential at the moment of the call, so a leaked agent token is useless on its own. Every decision is written to Agent Trail with the agent, the customer and the rule that made it.

The same adaptive risk engine that steps up your customers' transactions on value, velocity and behavior scores their agents' calls.

The risks

Agentic commerce risks and mitigation strategies

Most sites handle a customer's agent by blocking it, letting it in on the customer's password or tolerating screen automation. Each one costs revenue or control, and fraud models tuned on people misjudge agents both ways.

  • Legitimate agents blocked as bots

    The agent was sent by a paying customer, so a block page turns away the sale. Recognize verified agents and send them to get the customer's consent instead.

  • Agents on the customer's password or session

    You can't tell who did what, limit the agent or revoke it without a password reset. Give each agent its own scoped, short-lived token.

  • Agent impersonation

    A script claims to be a well-known agent. Verify the agent's identity, and bind its token to its own key with DPoP or mTLS so only that agent can present it.

  • Overspending and out-of-scope purchases

    An agent misreads the task or is manipulated into buying more. Put the customer's caps and categories in the token and check them on every call.

  • Stolen or replayed credentials

    Agents hold only a scoped token. The customer keeps their password, you keep your downstream credentials, and a copied token is useless without the agent's key.

  • Customer data over-exposed to agents

    An agent only needs part of what an API returns. Redact card numbers and other personal data, before the agent sees the response.

A delegated agent token compared with an agent signed in on the customer's password or session
You can tell which agent acted, and for which customerOn a shared password or session cookie, the agent is indistinguishable from the customer.Delegated tokenYesCustomer's loginNo
Limited to what the customer granted, such as spend capsAn agent on the customer's login can do everything the customer can.Delegated tokenYesCustomer's loginNo
Risky purchases go to the customer for approvalThe approval reaches the customer's own device, so the agent can't answer it.Delegated tokenCIBA approvalCustomer's loginNo
Useless to anyone who copies itDPoP or mTLS binds the token to the agent's own key.Delegated tokenYesCustomer's loginNo
The agent never holds your downstream credentialsAgent Authority swaps the scoped token for the downstream credential at the moment of the call.Delegated tokenYesCustomer's loginNo
Card numbers and personal data removed before the agent reads a responseDelegated tokenYesCustomer's loginNo
One agent revoked without a password resetDelegated tokenYesCustomer's loginNo
Every call recorded with the agent and the customer behind itOn the customer's login, the agent's calls look like the customer's own.Delegated tokenYesCustomer's loginNo

Screen automation is the third workaround: agents clicking through pages built for people break when a page changes, and look like the credential-stuffing tools you block. A delegated token gives them a supported way in.

Compliance

Agentic commerce compliance builds on open-banking consent

Agentic commerce is the open-banking consent pattern with a new actor: a customer authorizes a third party, within limits, and can take it back.

Open banking, PSD2 payment initiation and Australia's Consumer Data Right already require scoped, revocable, customer-approved access for third parties, and SecureAuth runs that pattern with FAPI 2.0. For agentic commerce compliance, the evidence is the same: consent captured with a full audit trail, consent management for GDPR, CCPA and LGPD, the customer's approval of each risky purchase, and a record of every agent call with the customer behind it. When a purchase is disputed, you can show who authorized it, the limits that applied and which agent acted.

OAuth 2.0 and 2.1
The customer authorizes the agent; the agent never sees a password.
OpenID Connect (OIDC)
Carries the verified customer the agent acts for.
Token Exchange (RFC 8693)
A narrower token for the agent, and narrower again for each sub-agent.
Rich Authorization Requests (RFC 9396)
Actions, spend caps, categories and purpose, finer than scopes.
Pushed Authorization Requests (RFC 9126)
Keeps large authorization requests out of the browser.
DPoP and mTLS
Sender-constrained tokens: only the agent holding the key can use them.
FAPI 2.0 (Financial-grade API)
SecureAuth is a certified FAPI 2.0 provider, for both the Security Profile and the Message Signing Profile.
CIBA
Decoupled approval by the customer, on their own device.
Client ID Metadata Documents (CIMD)
An agent is identified by an HTTPS address that publishes its own details, so it can connect without being registered in advance.
Dynamic Client Registration
Agents register as OAuth clients through a protected endpoint.
Passkeys (FIDO2 / WebAuthn)
Phishing-resistant sign-in for the customer who grants the access.

It works alongside the agent and payment protocols at the edge and in the payment rails: Web Bot Auth and HTTP Message Signatures (RFC 9421), Visa Trusted Agent Protocol and Mastercard Agent Pay identify agents; AP2 mandates, Visa and Mastercard agentic tokens and the Agentic Commerce Protocol move the money.

Agentic commerce for banks, fintechs, retailers and travel

Agentic commerce reaches any business where customers transact with an account. Agentic commerce affects these four industries first.

  • Banks

    Let agents check balances and pay known billers; send new payees to the customer for approval.

  • Fintechs

    Offer agent access as a standards-based feature your customers control.

  • Retailers

    Accept shopping agents with caps by order, month and category, instead of a block page.

  • Travel

    Let agents book within the traveler's budget and dates; changes go to the traveler.

Agentic commerce FAQ

What is agentic commerce?

Agentic commerce is buying, booking and account servicing done by AI agents on behalf of people. A customer asks an agent to reorder groceries, book a flight or pay a bill, and the agent visits the business's site or API to do it. The business has to confirm which agent it is and that the customer authorized it, then hold it to the customer's limits.

What is Know Your Agent (KYA), and how can merchants verify AI agent identity during checkout?

Know Your Agent (KYA) is the practice of verifying, before an AI agent transacts, who built it, which customer it acts for and what that customer allowed it to do: the agent equivalent of Know Your Customer. Verify the agent cryptographically instead of guessing from its traffic, then check the customer's grant. Portable agent identity comes from the agent's provider, not from each site: providers sign requests with HTTP Message Signatures (RFC 9421) and Web Bot Auth, and card networks vouch for enrolled agents through Visa Trusted Agent Protocol and Mastercard Agent Pay. That proves which agent is calling. Your own authorization server then issues a short-lived token, bound to the agent's key, that names the customer who authorized it, so a verified agent is recognized rather than blocked, and an impersonator is refused.

How does OAuth 2.0 apply to AI agent authorization in e-commerce?

OAuth 2.0 lets a customer grant an agent limited access without sharing a password. The customer signs in on your site and approves a consent screen; the agent receives its own short-lived token. Token exchange (RFC 8693) scopes that token to the task, Rich Authorization Requests (RFC 9396) carry the spend caps, merchants, categories and purpose, DPoP or mTLS binds it to the agent's key so a replayed copy is rejected, and CIBA sends risky purchases to the customer for approval.

What authentication do AI agents need to transact on our site, and should an agent ever use the customer's password?

Avoid the customer's password or session cookie: an agent holding them is indistinguishable from the customer, can't be limited and can only be stopped by a password reset. Agent-to-site authentication takes three checks instead. The agent proves its own identity, as an OAuth client or with signed requests. The customer authenticates with your normal sign-in, ideally a passkey or MFA. The agent then gets a delegated, short-lived token that names the customer and carries their limits, and every call it makes is authorized against them.

How do customers give consent to an AI agent to buy, with spending limits?

The customer signs in on your own page and approves a consent screen that names the agent and lists what it may do: for example see orders, add to cart and check out, up to $150 per order and $400 a month, in groceries only, for 30 days. Those limits travel in the agent's token and are checked on every call, and the consent is recorded with a full audit trail.

What are the main agentic commerce risks, and how do you mitigate them?

Six come up most: legitimate agents blocked as bots, agents running on the customer's password, agents impersonating well-known ones, purchases beyond what the customer wanted, stolen or replayed credentials and customer data over-exposed to agents. The mitigations are a verified agent identity, a delegated token per agent bound to its key, the customer's limits checked on every call, approval by the customer for anything risky, PII and PHI redaction and revocation that takes effect on the agent's next call.

How do autonomous AI agents execute secure financial transactions?

They act on a bounded delegation, not on the customer's credentials. Each call presents a short-lived token bound to the agent's key and is decided against the customer's grant: allowed, redacted, throttled, held for the customer's approval or denied. The customer keeps their password and you keep your downstream credentials, and the payment itself is authorized separately by the payment provider, network and issuer.

When does a customer have to approve an AI agent's purchase?

When the purchase is outside the customer's grant or the risk is high: over a spend cap, a new merchant or payee, a new shipping address or a transaction whose value, velocity or behavior is out of pattern. The approval goes to the customer, not the agent, as an out-of-band request on their own device (CIBA) showing what they are approving.

How do customers see and revoke the agents acting for them?

Customers get a “My agents” page on your site listing every agent they have authorized, what each can do and its limits, with revoke for each agent and revoke all. Revocation takes effect on the agent's next call, before its token expires.

What is agentic commerce compliance, and how do you prove what a customer authorized if a purchase is disputed?

Agentic commerce compliance means showing that every agent transaction was authorized by the customer, within their limits, with their personal data handled lawfully. Record the consent with a full audit trail, keep the customer's approval of each risky purchase, and record every agent call with the agent, the customer, the decision and the rule that made it. Customer consent management supports GDPR, CCPA and LGPD consent requirements, and FAPI 2.0 brings the open-banking security profile to agent access.

How does this work with Visa Trusted Agent Protocol, Mastercard Agent Pay and AP2, and why isn't a payment API enough?

It works alongside them. Visa Trusted Agent Protocol and Mastercard Agent Pay identify trusted agents, and AP2 mandates, network agentic tokens, Stripe Shared Payment Tokens and the Agentic Commerce Protocol carry the payment. A payment API authorizes the money, not the agent's access to the customer's account: it doesn't decide whether this agent may read orders, change a booking or use a saved address. SecureAuth adds that customer authorization on your site. It does not move money.

How is agentic commerce different from securing our own AI agents?

In agentic commerce the agent belongs to your customer or a third-party provider, and the customer is the one who grants, approves and revokes its access. Your own employees' agents and autonomous agents are granted access by your organization instead. Both get their own identity and a decision on every call; the AI agent identity and authorization use case covers your own agents.

Let your customers' AI agents buy, on their terms

See SecureAuth verify an agent, bind it to your customer and enforce their limits.

Updated