Agent Payments

The Problem

AI agents are executing payments at scale:

• Crypto exchanges: 60% of trades executed by agents (not humans clicking “buy”)
• B2B FinTech: Agents pay invoices, settle contracts, transfer funds between accounts
• Subscription services: Agents auto-pay recurring charges
• Supply chain: Agents release payments upon delivery confirmation

But payment systems have no agent identity layer:

• Who authorized this payment? Logs show “account 12345 paid $10,000”—not which agent, not which human authorized it
• Can we revoke an agent’s payment authority instantly? No—API keys require manual rotation, shared credentials affect all agents, OAuth tokens expire but don’t revoke mid-transaction
• How do we enforce limits? Payment rails enforce account limits, not per-agent limits (agent A can spend $1k, agent B can spend $100k—but both use same account)
• How do recipients verify payment came from an authorized agent? No cryptographic proof—they trust the payment rail, not the agent

This isn’t theoretical:

• $3.1 billion lost to payment fraud in 2025 (FTC)—unauthorized payments, account takeovers, privilege escalation
• Crypto exchanges report: “60% of trades executed by agents, but logs show ‘account acted’—compliance risk”
• MAS Payment Services Act (2027): Requires cryptographic proof of authorization + real-time revocation for AI agents executing financial transactions

Why It Matters Now

Regulators demand attribution:

• MAS Payment Services Act (2027): AI agents executing payments must carry cryptographic mandates with real-time revocation capability
• FATF Travel Rule: Cross-border payments require proof of originator identity—agents need verifiable identity, not just account numbers
• SOC 2 / ISO 27001: Auditors demand proof of who authorized payments—“account paid” isn’t sufficient

The infrastructure exists: W3C Verifiable Credentials for payment mandates, DIDs for agent identity, TRQP for real-time authorization checks. The platforms that adopt agent payment mandates first will win on compliance, fraud prevention, and customer trust.

---

How Affinidi Enables Agent Payments

The key shift: Instead of agents sharing API keys or account credentials, each agent gets a payment mandate—a W3C Verifiable Credential that encodes:

1. Agent identity (DID) - Which specific agent is authorized
2. Payment authority - What the agent can pay (max amount, recipient allowlist, payment types)
3. Issuer signature - Who authorized this mandate (user’s DID, CFO’s DID, account owner’s DID)
4. Expiry & revocation - Mandate valid until date X, revocable in real-time via Trust Registry

When an agent executes a payment:

1. Agent presents mandate to payment rail
2. Payment rail verifies:
   • Signature valid? (cryptographic proof issuer authorized this agent)
   • Agent still authorized? (TRQP query: mandate not revoked?)
   • Payment within limits? (amount, recipient, type match mandate)
3. If all checks pass, payment executes and logs: agent DID + mandate + signature + timestamp

Technical Foundation

• Agent Gateway intercepts payment requests, enforces mandate verification before execution
• Elements Services issues W3C Verifiable Credentials encoding payment mandates:
  • Max amount per transaction
  • Recipient allowlist (only pay these addresses/accounts)
  • Payment types (crypto only, fiat only, subscriptions only)
  • Expiry date + issuer signature (user DID, company CFO DID)
• Trust Registry (TRQP) provides real-time mandate status:
  • “Is this mandate still valid?” (not revoked, not expired)
  • “Is this agent authorized to pay this amount right now?”
• did:webvh identifiers for agent + issuer—tamper-evident, time-travelable (auditors can verify: “Was this agent authorized when the payment executed?”)

Example Flow: Crypto Trading

[User Alice wants agent to auto-trade crypto]
  ↓
Alice issues payment mandate to agent (did:webvh:alice-trading-agent):
  - Max: $10,000 per trade
  - Asset types: BTC, ETH only
  - Expires: 30 days
  - Issuer: Alice's DID + signature
  ↓
Agent receives mandate (stored in Affinidi Vault)
  ↓
[Agent decides to buy 1 BTC = $8,500]
  ↓
Agent presents mandate to exchange:
  - "I'm did:webvh:alice-trading-agent"
  - "My mandate: max $10k/trade, crypto only, signed by Alice"
  ↓
Exchange verifies:
  ✓ Signature valid (Alice authorized this agent)
  ✓ TRQP query: mandate not revoked
  ✓ Amount check: $8,500 < $10,000 limit
  ✓ Asset type: BTC = allowed
  ↓
Trade executes, logged with proof:
  - Agent: did:webvh:alice-trading-agent
  - Mandate: [hash of VC]
  - Trade: Buy 1 BTC @ $8,500
  - Timestamp: 2026-07-22T10:15:00Z
  ↓
[10 days later: Alice revokes mandate]
  ↓
Trust Registry marks mandate invalid
  ↓
[Agent attempts another trade]
  ↓
Exchange queries TRQP: mandate revoked → trade blocked

What this means:

• Compliance: Exchange can prove “Agent did:webvh:alice-trading-agent, authorized by Alice (did:webvh:alice), bought 1 BTC under mandate [hash], timestamp 2026-07-22”
• Real-time revocation: Alice revokes mandate, next payment blocked instantly (no API key rotation, no waiting)
• Audit trail: Regulators query Trust Registry: “Was this agent authorized when the payment executed?”—get cryptographic proof
• Fraud prevention: If agent’s mandate is stolen, attacker can’t exceed limits; user revokes instantly

---

Real-World Applications

Crypto Trading: Per-Agent Attribution

Problem: Agent executes trades on behalf of user. Exchange logs show “account 12345 bought 10 BTC”—not which agent, not which user authorized it. Compliance risk: auditors can’t prove attribution.

Solution: User issues payment mandate to agent (W3C VC): max $10k per trade, crypto purchases only, expires 30 days. Agent presents mandate with each trade. Exchange verifies signature + queries Trust Registry.

Outcome:

• Exchange logs prove: Agent [DID], authorized by User [DID], bought 10 BTC under mandate [hash]
• FATF Travel Rule compliant: Cryptographic proof of originator identity (agent DID + user DID)
• Real-time revocation: User revokes mandate, next trade blocked instantly

---

B2B Payments (FinTech): Cross-Org Trust

Problem: Company A’s agent pays Company B’s invoice. Company B can’t verify payment came from authorized agent—could be fraud, could be rogue employee.

Solution: Company A’s CFO issues payment mandate to agent (signed by CFO’s DID). Agent presents mandate with payment. Company B verifies: signature valid? CFO authorized? Trust Registry confirms mandate not revoked.

Outcome:

• Company B trusts payment came from authorized agent—cryptographic proof for audit trail
• Company A’s compliance team can prove: “Agent [DID], authorized by CFO [DID], paid invoice [#123] under mandate [hash]”
• Fraud blocked: Rogue employee can’t issue mandates (no CFO signature); stolen credentials revoked in real-time

---

Subscription Services (SaaS): Real-Time Revocation

Problem: User’s agent auto-pays monthly subscription ($50/month). User cancels subscription but agent still executes payment—no real-time revocation, API key still valid.

Solution: User issues payment mandate with expiry: “Pay SubscriptionCo up to $50/month, expires when I revoke.” When user cancels, Trust Registry marks mandate invalid. Next payment attempt: agent queries registry, mandate revoked, payment blocked.

Outcome:

• No runaway subscriptions: User controls agent payment authority in real-time
• User experience: Cancel subscription, payment stops immediately (not “wait for billing cycle”)
• SaaS platform: Cryptographic proof user authorized payment (compliance with payment regulations)

---

Supply Chain Payments (Manufacturing): Conditional Payments

Problem: Buyer’s agent pays supplier upon delivery confirmation. No cryptographic proof supplier delivered goods—agent pays based on spoofed email confirmation (fraud).

Solution:

1. Buyer issues payment mandate to agent: “Pay Supplier [DID] up to $100k, only if valid delivery credential presented”
2. Supplier delivers goods, issues delivery credential (W3C VC): goods delivered, signed by logistics provider
3. Agent verifies delivery credential before paying: signature valid? Logistics provider authorized (TRQP query)?
4. If valid, agent executes payment; if not, payment blocked

Outcome:

• Agent only pays when supplier proves delivery cryptographically—fraud blocked
• Audit trail: Buyer’s finance team can prove: “Agent paid Supplier under mandate [hash], delivery confirmed by logistics credential [hash]”
• Supply chain trust: No disputes—cryptographic proof of delivery + payment authorization

---

Why Affinidi

	Affinidi Agent Payments	API Keys	Shared Credentials	OAuth Tokens
Per-agent attribution	✓ DIDs + signed mandates	✗ Key rotates, no agent identity	✗ Shared = no attribution	⚠ Token scopes, no agent identity
Real-time revocation	✓ TRQP before payment	✗ Manual key rotation	✗ Password change = all blocked	⚠ Token expiry, not instant
Payment limits	✓ Encoded in VC mandate	✗ Hardcoded or DB lookup	✗ No per-agent limits	⚠ Scopes, no amount limits
Audit trail	✓ Agent DID + mandate + signature	⚠ Key ID, no user link	✗ Account acted, no agent	⚠ Token ID, no mandate
Cross-org trust	✓ DIDComm + TRQP	✗ Same-org only	✗ Same-org only	✗ OAuth per-org, no federation

What this means:

• API keys solve authentication but not attribution (key rotates, logs show key ID, not agent or user)
• Shared credentials mean all agents use same account—no per-agent limits, no attribution
• OAuth tokens add scopes but don’t encode payment limits (can’t say “agent can pay max $10k”) and don’t support real-time revocation mid-token-lifetime

Affinidi provides per-agent DIDs + payment mandates + real-time revocation + cross-org trust—the only architecture that scales agent payments to regulatory compliance requirements.

Proof It Works

• W3C Verifiable Credentials - Industry-standard mandate format
• TRQP Integration - Real-time mandate validation before payment execution
• Agent Gateway - Drop-in proxy that enforces mandates for any payment rail (crypto, fiat, API-based)
• Self-hostable - Deploy Agent Gateway + Trust Registry on your infrastructure

---

Get Started

For Developers

Build your first agent payment flow

Issue a payment mandate, have agent execute payment with mandate verification—end-to-end in under an hour.

Start building →

---

For Platform Teams

See a live demo of agent payments

Watch agent execute payment with mandate, see real-time revocation, view audit trail with cryptographic proof.

Schedule demo →

---

For Enterprises

Custom deployment consultation

Integrate payment mandates into your FinTech platform, connect to Trust Registry, configure mandate policies.

Talk to an expert →

---

Related Resources

Technical Deep Dives

• Verifiable Credentials - How payment mandates work
• Decentralized Identifiers (DIDs) - How agents get cryptographic identities
• Trust Registries & TRQP - Real-time mandate validation

Related Solutions

• Per-Agent Attribution - Audit trails that prove which agent did what
• Runtime Agent Governance - Control before action, not logs after
• Cross-Org Agent Trust - How agents prove identity across organizations

Case Studies

(Coming soon: Crypto exchange agent payment implementation)