Skip to main content
Attesso is a spending-control layer. It authorizes a proposed action against a user-signed mandate and returns a decision with signed evidence. Attesso never moves money, holds cards, or connects to your payment account. You keep your existing PSP (Stripe, Adyen, Wallester, Airwallex, or any other) and bind each Attesso authorization to an action on that rail. This guide shows the exact pattern for taking an ALLOW from Attesso and executing it against your own PSP. The pattern is the same for every provider: authorize first, execute second, then report finality.

The core pattern

Attesso is PSP-agnostic: it never needs to know which provider you use. You bind the authorization to your rail with two fields:
  • external_action_reference: your idempotency key for the PSP call.
  • provider_transaction_reference: the PSP’s transaction/charge ID (on commit).

Step 1: Authorize the proposed action

The commitment is the SHA-256 of the domain line attesso:authorization:commitment:v1 plus a random 32-byte opening you keep; reveal the opening on commit (Step 3), and never reuse the pair. Response (ALLOW):
Execute only when can_execute is exactly true and before execute_before. A DENY or INDETERMINATE means do not call your PSP.

Step 2: Execute on your PSP

Now bind the ALLOW to a real action on your rail. The request you send to your PSP must be derived from the same immutable proposed action you sent to Attesso. Never rebuild it from mutable UI or agent state.

Worked integrations

Tested, end-to-end recipes for specific providers:
  • Stripe: PaymentIntent with server-side confirm, decline and 3D Secure handling, test mode.
  • Airwallex: sandbox flow, 3D Secure, reconciliation.
For any other provider the pattern is the same: authorize on Attesso, execute on their API with your external_action_reference, then report finality. Sketch, for Adyen:

Step 3: Report finality

After the PSP returns a definite result, report it to Attesso. This is what closes the loop and produces the evidence.

Commit (the PSP accepted the action)

Cancel (the PSP rejected, or you aborted)

Idempotency and safety

  • Use a separate idempotency key per boundary: one for the authorization, one for the PSP call, one for the commit/cancel.
  • Retries must reuse the same key only when the operation and bytes are logically identical. Never turn a changed operation into a retry.
  • If the PSP call times out, reconcile before committing or canceling: a timeout is not proof the provider did nothing. See the reconciliation guide.

What this buys you

  • Spending control: the agent cannot exceed the user-signed bounds.
  • Verifiable evidence: the signed bundle proves the user approved the exact mandate and the agent stayed inside it. Anyone can verify it without trusting Attesso (see verify evidence).
  • No float, no license, no provider-adapter matrix: you keep your PSP, your funds, and your compliance responsibility.