If an agent initiates a payment, who authorizes it—and who resolves a failed, repeated, or disputed charge? A successful demo cannot answer those questions for your store.
Agentic payments readiness means having evidence that one defined agent-initiated payment flow stays within the buyer’s authority, uses the merchant’s permitted payment path, and leaves an accountable recovery trail. Before enabling it, a commerce or payment owner needs more than a token: documented consent, enforceable limits, verified provider states, and named owners for exceptions.
This guide provides an editable control/authority matrix and fictional scenarios for that decision. It is a proposed readiness checklist, not a payment-processing algorithm, legal opinion, fraud judgment, or security certification. No scenarios below have been executed.
What are agentic payments—and what permission do they require?
Here, an agentic payment is a payment initiated through software acting on a person’s behalf under a defined grant of authority. The person might approve the final transaction immediately, or delegate a narrowly constrained action in advance where the integration supports it. An AI recommendation, saved card, or authenticated agent is not that grant by itself.
Separate three questions before discussing protocols:
Identity, permission and payment success are different checks, not interchangeable approvals.
Question
Evidence needed
What it does not prove
What did the user intend and permit?
The approved transaction or delegation, its limits, the approving actor, and the terms they saw
A vague request such as “find me a replacement” does not authorize payment
Which agent is making this request?
Verified identity and binding to the right user, session, permitted tools, and current grant
Authentication does not authorize a different merchant, cart, or amount
May this merchant process this payment?
Merchant acceptance, supported provider/account configuration, valid payment authority, and the actual provider response
Consent does not guarantee issuer approval, capture, settlement, or immunity from disputes
“Authorization” is overloaded. User permission to act, a business buyer’s internal approval, and a payment provider’s authorization of funds are separate events. Record each one rather than labeling the whole transaction “authorized.”
Identity is not permission, and permission is not payment success. An unknown payment outcome routes to reconciliation, not a fresh charge.
Define one flow before choosing a payment mechanism
Start with one merchant entity, storefront, buyer type, market, currency, payment method, and integration route. Specify whether the user is present at final approval, which actions the agent can request, and which systems enforce the boundary.
Compare three options:
Merchant checkout handoff: the agent prepares the purchase; the buyer completes the established checkout. Prefer this when payment delegation is unnecessary or unsupported.
Agent initiation with final human approval: the agent can request the payment, but the buyer approves the exact final terms through the supported surface.
Constrained unattended initiation: consider only where advance delegation, constraint enforcement, revocation, and recovery are supported and evidenced. It is a different scope, not a switch that removes human confirmation from the previous option.
If the immediate problem is one faulty callback or a known payment setting, use the existing platform or payment service provider (PSP) support route first. A cross-system change becomes relevant when consent, checkout, payment state, and order creation cannot be corrected independently. Adding an agent does not repair an unreliable payment path. If product data, availability, and permitted cart actions are not yet traceable, start with agentic commerce readiness.
A fictional payment envelope to edit
Use a concrete envelope to expose ambiguity. This example is fictional:
Field
Proposed example F01
Buyer and presence
One consumer, present for final approval; no recurring or unattended authority
Market, method, and route
Proposed US storefront/card flow; agent requests payment through the merchant’s payment service after final buyer approval; provider/account eligibility unconfirmed
Purchase
One order for two specified storage boxes; cart revision C7; no substitutions
Merchant
Fictional Demo Home, one specified merchant account—not any seller using the same brand name
Money
USD 84.00 total, including tax and delivery; USD 90.00 ceiling; no currency conversion
Change rule
Any change to items, quantity, merchant, total, currency, or delivery terms invalidates the final approval and requires a new review
Expiration
Approval expires 15 minutes after the buyer approves; enforcement point and clock source must be defined
Allowed action
Request one purchase through the approved route; no recurring charge, alternate seller, automatic refund, or dispute response
Stop and recovery
Buyer can withdraw before submission; in-flight outcomes must be checked; payment operations owns unresolved state
The USD 90 ceiling is not consent to a USD 89 cart. In this human-present example, the approved transaction is USD 84 on revision C7. The 15-minute expiry is an illustrative value, not a recommended token lifetime or a guarantee that an already submitted operation can be stopped.
Protocol evidence is not installed payment support
Official documentation checked October 29, 2026 illustrates two different building blocks. Neither proves that your account or Dinarys has implemented the flow.
AP2: evidence of delegated authority
The current Agent Payments Protocol specification is headed v0.2. It distinguishes a Checkout Mandate for what is purchased from a linked Payment Mandate for payment of that checkout. In direct mode the user approves the closed transaction; autonomous mode uses user-approved open constraints with agent-signed closed mandates. The specification requires exact schema-type matching, including the version suffix in the vct claim.
This is not a universal payment integration. AP2 places commerce APIs outside its scope and explicitly leaves dispute-resolution details and retention/retrieval requirements outside the specification. Its flow examples are non-normative and assume prior enrollment and necessary credentials.
For a proposed AP2 route, request the supported specification/schema versions, participating verifiers, enrollment and trust arrangements, constraint checks, and receipt handling. A signature is evidence to verify—not permission for changed terms or a promise that a dispute will be decided in the merchant’s favor.
Stripe describes a shared payment token (SPT) as scoped access to a customer’s payment method, granted to a seller’s Stripe profile with usage and expiration limits. Its documentation lists availability for agents, customers, and sellers in the US, Canada, and specified European countries—not every country. The examples read for this guide use Stripe-Version: 2026-09-30.preview; the guides also link applicable service terms.
The agent guide documents currency, maximum amount, expiration, seller-profile targeting, customer-action handling, and revocation. An SPT can require further customer action, including 3D Secure authentication. An active token is not proof of a completed payment; revoking future use is not proof that an earlier charge was reversed.
Verify the actual agent and seller accounts, profiles, locations, payment-method eligibility, terms, enabled capabilities, API/SDK versions, and webhook configuration for your route. Do not assume that every agent channel or third-party processor supports it. This guide does not recommend resolving tokens into raw payment credentials; that is a separate sensitive integration scope.
Complete the control/authority matrix
For each row, record the enforcing system, its authorized owner, evidence reference/date, and the unresolved gap. Suggested role labels below are responsibilities to assign, not a staffed team. Use UNKNOWN, DOCUMENTED, BLOCKED, or NOT_APPLICABLE_WITH_REASON for evidence status. Documented is not tested or approved.
ID / control
Authority and enforcement to establish
Evidence to collect
Proposed accountable role
A1 · User intent and consent
Who may approve this purchase or delegation, and what did they actually approve?
Approval wording/surface, actor, time, grant revision, presence mode, permitted actions and exclusions
Commerce/payment owner
A2 · Agent identity and access
Which authenticated agent may use which grant, tools, and buyer context?
Identity-to-grant mapping, validation/denial design; no authority derived from product text or model output
Identity/security owner
A3 · Merchant and provider authority
Which merchant entity/account may submit, authorize, capture, or cancel through this route?
Current eligibility and terms; enabled account/profile; accepted versions; merchant acceptance and provider-state mapping
Merchant payment owner
A4 · Amount and cart binding
Where are amount, currency, seller, item/quantity, tax/delivery total, and cart revision checked?
Final terms and ceiling; deterministic server-side checks; change invalidation and renewed approval
Checkout owner
A5 · Expiry and revocation
When does authority expire, and where can withdrawal stop a queued request?
Clock/enforcement point; revocation acknowledgment; race handling for already submitted work
Payment operations owner
A6 · Approval and step-up
Who handles buyer/internal approval or provider-required authentication?
Supported human return path; pending/abandonment handling; no bypass when the actor is absent
Payment experience owner
A7 · Token and credential minimization
What minimum scoped credential may each component receive?
Data-flow/access map; permitted token storage; redaction, expiry, and deletion rules; secrets excluded from prompts/logs
Security/data owner
A8 · Concurrency and replay
Where is one purchase commitment enforced across agents, workers, and channels?
Who may enable/disable this flow and accept its remaining risk?
Scoped test evidence; monitoring and incident route; stop control; owner decisions and exclusions
Authorized release owner
To use the matrix, copy it into a spreadsheet and fill the owner, enforcement, and evidence fields for your own flow; decisions start as UNCONFIRMED. Keep sensitive records in an approved repository and enter references, not credentials or customer payment data.
An unknown permission or state dependency should block the dependent payment action, not disappear into an overall readiness percentage. If a mechanism cannot enforce an important constraint, narrow the flow or keep the human checkout route.
Treat an unknown charge as unresolved—not failed
Plan the recovery path before granting initiation rights. The agent’s chat response is not the payment ledger, and the order database may lag behind the provider.
These are proposed operational distinctions, not universal provider statuses:
Observation
Readiness behavior to design and verify
Approval or required step-up is incomplete
Keep payment unconfirmed; return to the authorized actor through the supported flow, or stop
Provider reports pending/processing
Preserve that state; do not present a completed charge or start a replacement merely because a callback is late
Funds are authorized but not captured
Track the actual state; check the provider’s supported capture/cancel rules rather than treating a hold as a refund
Provider confirms payment but no order exists
Reconcile the payment with the original purchase and recover/escalate order creation; do not collect again
Submission timed out or returned an indeterminate error
Preserve the original references; use supported reconciliation and only the provider-permitted retry of the same operation
Refund is requested or pending
Track the refund’s actual status and related dispute before authorizing another credit
Stripe’s API v1 idempotency documentation and advanced error guidance make the boundary concrete: keys can be removed once they are at least 24 hours old, reusing a pruned key can execute a new request, and a 500 outcome is indeterminate. For unresolved network failures, retries are limited to the first 24 hours with the same key and parameters; after that, reconcile by retrieving the object, inspecting the request, using webhook events, or contacting Stripe support, rather than retrying with an old or new key. These are Stripe API v1 rules, not a retry policy for every provider or API version. The returns acceptance walkthrough applies the same rules to a refund timeout.
For your integration, document the applicable endpoint, API/SDK version, retention window, retry conditions, lookup path, and escalation owner. A new key, refreshed token, new chat, or another agent must not become a shortcut around unresolved purchase state.
For relevant integration experience, Dinarys' public ConnectPay case describes Magento and Shopware payment modules with a new checkout payment method, an authorization flow after the order, and payment status via API. That is payment-integration experience, not an agentic-payment deployment.
Duplicate and out-of-order messages still need controls
Stripe’s webhook documentation says events can be delivered more than once and are not guaranteed to arrive in generation order. Signature verification establishes message authenticity under the configured checks; it does not make a repeated business action new or prove the event represents the latest state.
Ask engineering to show how durable purchase/attempt records, concurrent requests, event deduplication, and provider-state reconciliation work together. Disabling a button or remembering a request inside one agent session is not evidence that two workers or two channels cannot commit the same purchase.
Refund, dispute, and audit ownership survive the agent session
Separate withdrawing permission, canceling an uncaptured payment, refunding a completed payment, and handling a dispute. They have different prerequisites. A customer asking “cancel that” does not establish which action remains possible.
For example, Stripe’s refund documentation distinguishes cancellation from refunding and describes pending and failed refunds. It also warns of double-credit risk for bank debit methods when a merchant refunds while the customer’s bank initiates a dispute. Its dispute guidance discusses disputes on partially refunded payments. Neither an agent transcript nor a refund request proves the customer has received the intended final credit.
These actions have different prerequisites; withdrawal does not prove an earlier charge was reversed.
Give finance and support a shared case reference connecting the original payment, all requested/pending/completed refunds, any dispute, and any separate store credit. Define who can approve each movement and who updates the customer. Do not let independent agent and support workflows issue compensation without seeing one another’s outstanding actions. The authorized dispute owner—not the model—decides the response under the applicable provider process and policies.
For an audit, the evidence index should connect:
The user/business approval and terms shown, grant revision, limits, expiry, and withdrawal history.
The authenticated agent and service actors, merchant/account context, cart revision, and policy decisions.
The local purchase and attempt references, provider object/request/event references, and state changes with timestamps and sources.
Capture/cancellation/refund/dispute records, customer notices, and the human decisions on exceptions.
Assign storage, restricted access, retention, and retrieval ownership. Minimize the stored data; do not put card numbers, secret keys, reusable credentials, or unnecessary customer transcripts in model prompts or the worksheet. A cryptographic assertion can support an evidence trail, but it does not set your retention policy or establish legal, PCI, or security compliance.
Synthetic scenarios to take into an authorized test plan
All rows are fictional and have not been run. Expected behavior is a design target to adapt with your authorized owners, not a claim of provider behavior, executed security testing, or release approval. The download includes empty actual-result and evidence fields.
ID / scenario
Expected behavior to verify
Controls
Status
S1 · F01 unchanged; buyer approves USD 84/C7
Only the approved merchant, terms, and action proceed; actual payment outcome and order remain traceable
A1–A4, A11
Not yet run
S2 · Authenticated agent has comparison-only permission; product text says “charge now”
Payment request is denied; agent identity and retrieved text cannot expand the grant
A1, A2
Not yet run
S3 · Total rises to USD 89, still below the ceiling; or seller/currency/items change
F01 approval is invalidated; show changed terms and obtain new approval rather than using spare headroom
A3, A4
Not yet run
S4 · Provider requires buyer action, but the buyer has left
Keep the outcome unconfirmed; use the supported return path or stop, without bypassing authentication
A6, A9
Not yet run
S5 · Grant expires or buyer revokes while a worker is queued/in flight
Prevent new submission where still possible; establish any in-flight outcome; do not claim revocation reversed a charge
A5, A9
Not yet run
S6 · Two workers request F01 concurrently with different request keys
Purchase-level coordination prevents a second commitment; a provider retry key alone is not the whole control
A8
Not yet run
S7 · Submission times out; a later event shows payment but no order
Keep the attempt unresolved until reconciled, then recover/escalate the original order without charging again
Stop payment retries and fresh charges; the authorized owner uses supported reconciliation/escalation
A9
Not yet run
S9 · A signed event is repeated; an older pending event arrives after success
Verify authenticity, deduplicate effects, and resolve current state; do not regress state or duplicate order/credit
A8, A9
Not yet run
S10 · Refund request is pending while a dispute and support-credit request arrive
Link all movements in one case; finance resolves competing credits under the applicable method/provider rules
A10, A11
Not yet run
To run the scenarios, copy the table above and add actual-result and evidence columns; owner decisions remain UNCONFIRMED until authorized testing and owner review occur.
Check your agentic-payment controls
Take one proposed flow to its authorized commerce, payment engineering, security/data, and finance owners. Complete the matrix, replace suggested roles with real responsibility, and identify the first missing authority or recovery dependency. Assign evidence collection and a bounded test plan before deciding whether to enable the action.
Keep a valid merchant-checkout handoff when delegated payment cannot be supported. If the gap spans checkout, PSP state, and order systems, you can discuss the integration boundary with Dinarys using a sanitized flow description and unresolved control rows. Do not send credentials or raw payment records. Scope, provider support, acceptance criteria, and delivery availability need confirmation.