AI AGENT PAYMENT AUTHORIZATION API

AI agents can buy.
Make sure they buy only what was approved.

MandateShield verifies that a final AI-initiated purchase still matches signed human authority. It enforces per-transaction and cumulative budgets, merchant, currency, consent, expiry, identity and replay controls outside the model, then creates a reservation a trusted gateway can consume once before payment submission.

For online stores, marketplaces, payment providers and agent builders. No card data required.

LIVE BOUNDARY EXAMPLE

#ms_interactive

BLOCK

AI agent requests

$1,499
HUMAN AUTHORITY

Spend up to $150 at Rail Merchant.

!

Requested amount exceeds the hard cap by $1,349.Final merchant: Rail Merchant

$1,499 stopped at the boundaryreceipt ready

One control layer across

AP2TAPUCPx402ACP
Mandate = delegated AI purchase authority.Not SEPA · Not direct debit · Not e-signature · No money movementExact category definition →

BUILT FOR YOUR PLACE IN THE FLOW

Choose your role. See exactly where MandateShield fits.

The same execution boundary works differently for an agent, a merchant, a marketplace and a payment platform.

YOUR FASTEST PATH

Give every agent a payment permission layer.

Call MandateShield as an MCP tool, A2A skill or HTTP endpoint immediately before the agent reaches checkout.

WHAT YOU GETOne stable policy surface across agent frameworks and payment rails.Connect an agent

THE PROBLEM

An approved payment method is not an approved purchase.

A person may authorize an agent to “buy a refundable ticket for under $150.” A manipulated page, tool or second agent can still push the final checkout to $1,499 at another merchant.

MandateShield keeps the approved limits in an immutable, account-scoped mandate. The model cannot rewrite them inside the execution request.

01

Receive the purchase

Send the final purchase plus signed authority evidence to one API. Private keys and payment credentials never leave their owners.

02

Check every boundary

The engine verifies signatures and bindings, then evaluates hard limits, identity and replay. Prompt-injection patterns remain an advisory review signal, never the source of authority.

03

Allow or block

Your system receives a clear result, exact reasons and a portable ES256-signed receipt anyone can independently verify.

WHAT CHANGES

One verification gate can stop the wrong order before the provider call.

$0card data sent to MandateShield
durable authorization record per account-wide idempotency key
cryptographic proof: input evidence + signed decision

FREE LIVE VALIDATOR

See the decision before you integrate.

Change the money or permissions with plain controls, then attack the same mandate five ways. The results come from the live public analysis API—not a recorded animation. Sandbox results are never executable.

LOAD A SCENARIO

Live policy engine · no account · no card or personal data

READY

Change the purchase. See where authority ends.

Run one decision or attack the same mandate five different ways.

Developer mode: edit the complete JSON envelope
purchase-envelope.json
Sent only to this live sandbox

Ready for inspection

Run the sample or change a constraint to see the verdict.

ONE POLICY, EVERY RAIL

Keep the control when standards change.

AP2, TAP, UCP and x402 cover different parts of agentic commerce. MandateShield verifies supported signature formats and normalizes payment-relevant facts so merchant policy and audit evidence remain stable as rails change.

Read the merchant security guide →
AP2Mandate and intent
TAPAgent identity
UCPCheckout context
x402Machine payments
ACPOrder integrity
CustomSigned envelopes
VERIFY → CONSUME → COMMIT / RELEASELIVE
const reservation = requireAllowed(await verifier.verifyAuthority({
  envelope: purchase,
  evidence: signedAuthority
}))
const base = {
  compact: reservation.signed_receipt.compact,
  expected_envelope: purchase,
  expected_audience: processorAudience
}

const consumed = await processorGate.transitionExecutionAuthorization({
  ...base, action: "CONSUME",
  idempotency_key: `${attemptId}:consume`
})
if (consumed.transition_state !== "CONSUMED") stopPayment()

const outcome = await submitOnceToProvider()
if (outcome.status === "UNKNOWN") {
  await queueProviderReconciliation(outcome.reference)
  throw new Error("Provider outcome requires reconciliation")
}

await processorGate.transitionExecutionAuthorization({
  ...base,
  action: outcome.status === "COMMITTED" ? "COMMIT" : "RELEASE",
  idempotency_key: `${attemptId}:${outcome.status.toLowerCase()}`,
  processor_result: outcome.authenticatedAssertion
})

SMALL INTEGRATION, HARD BOUNDARY

Reserve, consume once, then report the outcome.

Production adds an immutable mandate registry, account-pinned issuer keys, one-time challenges, atomic cumulative-budget reservations and durable receipts. MandateShield never submits the payment: the existing gateway must enforce the state transition.

  • Separate VERIFY and audience-bound PROCESSOR keys
  • Lifetime, UTC-day and UTC-month cumulative spend limits
  • Exactly-one authorization consumption before provider submission
  • JWS, AP2 closed-payment and TAP-shaped evidence projections
  • Portable ES256 decision receipts and public JWKS
  • Conservative handling of unresolved processor outcomes
Read the API docs →

MODEL THE BUSINESS CASE

Price the boundary against the value moving through it.

Set your volume and average purchase. The calculator finds the lowest-cost published plan and shows the effective software cost per 1,000 verification decisions.

ANNUAL PURCHASE VALUE AT THE BOUNDARY$750,000,000

Lowest-cost planScale

Estimated monthly cost$3,749

Software cost / 1,000 decisions$7

Estimated annual software cost$44,988

Purchase value is boundary throughput, not promised savings. Published plan pricing determines the software-cost figures; actual loss avoidance depends on your traffic and threat rate.

Choose Scale

START FREE, SCALE BY USAGE

Production controls from $99 per month.

No sales call, seat fee or annual contract. Create the account, choose a plan and create role-scoped live keys in the dashboard.

Most popular$499/month

50,000 verification decisions included

Compare all plans →

LEARN WITHOUT A SALES CALL

Everything needed to make the decision.

Practical, evergreen references for merchants and developers implementing autonomous checkout.

PLAIN-ENGLISH ANSWERS

Common questions about AI-agent payment control.

Is MandateShield SEPA or direct-debit mandate software?

No. MandateShield checks bounded authority for autonomous AI-agent purchases. It does not collect IBANs, signatures, debit instructions or payment credentials.

What does MandateShield do?

MandateShield checks an AI agent's proposed purchase against per-attempt and cumulative limits, reserves approved authority, and lets a trusted payment gateway consume that reservation once before reporting a committed or released outcome.

Who is it for?

Online stores, marketplaces, payment providers and AI-agent builders that allow software agents to place orders or initiate payments.

Does it replace a payment processor or fraud tool?

No. It adds a pre-payment authorization state machine. The merchant's gateway must enforce CONSUME before provider submission and report COMMIT or RELEASE; card processing, fraud scoring, sanctions screening and settlement remain with existing providers.

Does MandateShield receive card data?

No. The API evaluates policy metadata such as amount, currency, merchant, consent and expiry. Payment credentials stay with the merchant's payment provider.

Which agent-payment protocols are supported?

The policy API accepts AP2, TAP, UCP, x402, ACP and custom envelopes. Strict v2 verifies JWS, an AP2-shaped closed-payment SD-JWT projection with RFC 9901 KB-JWT, and normalized TAP-shaped RFC 9421-style evidence. Raw MPP is not parsed today; final MPP terms can be normalized into a signed custom envelope by the integrator. Full AP2 checkout/delegate-chain and Visa TAP trust-store processing remain external.

AUTONOMY NEEDS BOUNDARIES

Let agents buy. Keep the human mandate in control.

Check a purchase free