Back to resources

What Is Per-Transaction Authorization? Approving the Request Isn't the Same as Removing the Access

November 2026  /  8 min read   /  
Britive Team

“Per-transaction authorization” usually comes up in conversations about AI agents, but the problem behind it is older than agents. A valid identity, already allowed to be somewhere, does something it shouldn't. The permission was real. The action wasn't acceptable. 

Per-transaction authorization answers that by moving the decision to the request itself. Dynamic evaluation of an access request is the right direction when it comes to securing rapidly-changing access needs in modern environments, but checking the request isn't the same as dynamically managing the access itself. That access is still the most important piece, as the thing that makes a stolen credential, a misdirected agent, or a bypassed control a valuable target for attackers. 

What Is Per-Transaction Authorization? 

Per-transaction authorization evaluates each access request at the moment it's made, against the exact resource, action and context, instead of trusting a permission granted earlier. The decision covers only that given access request. The next request, even if it’s from the same identity during the same session, receives its own evaluation decision. 

A transaction in this context is a single action against a resource: a database query, an API call, a configuration change, a tool call made by an AI agent. Each one is judged on what it touches, who or what is asking, and the conditions at that moment. The NHIMG glossary describes it as a control that "evaluates each individual action at the moment it is attempted." 

How Is Per-Transaction Authorization Different From Role-Based and Session-Based Access? 

Role-based access asks whether an identity can generally do something. Session-based access decides once, at login or when a token is issued, and trusts what follows. Per-transaction authorization asks a narrower question: should this exact request proceed right now, given what it touches and the conditions around it? 

Roles describe what an identity might need. They're assigned in advance, they accumulate, and they're reviewed on a calendar. Anything the role allows is allowed, whether or not anyone expected that particular use. 

Session-based access is a step forward from the role-based model. Zero trust moved trust from the network onto the identity, and NIST SP 800-207 sets the baseline plainly: "Access to individual enterprise resources is granted on a per-session basis." 

But even session decisions age. They're often made at the beginning of a session, and every request after it inherits that verdict, including requests nobody looked at and conditions that changed after the session began. 

Per-transaction authorization takes the zero trust principle even further down, applying it from the session to the individual request. Verification stops being something that happens at login and becomes something that happens every time access is used. 

Why Does Per-Transaction Authorization Matter Now? 

If every identity holds access it isn't using at any given moment, every access request is a chance for that access to be misused. 

AI agents raise the stakes because they chain many actions inside one session at machine speed, with no person reviewing each step. The same logic applies to pipelines and people. 

Picture three requests to change the same production database in one afternoon: 

  • An AI agent working a remediation ticket wants to alter a table. 
  • A deployment pipeline wants to run a schema migration. 
  • An engineer wants to fix a bad record by hand. 

Under a role-based access model, all three requests go through if the role allows writes. Under a session-based access model, all three go through if their sessions are valid. Under per-transaction authorization, each one is judged for what it is: this change, to this database, by this identity, for this reason, right now. 

The agent is where that difference matters most. A person in an admin session still pauses, reads the screen and notices when something looks wrong. An agent reasons through each next step, but it moves from one tool call to the next without a second look from anyone, and a decision made when its session started covers every call it makes after. 

Pipelines and service accounts have the opposite problem: they run using roles and keys that were granted once and rarely revisited. People are the most familiar case. Step-up checks before a sensitive action are already per-transaction authorization, applied where the risk is highest. 

The pattern holds outside infrastructure, too. An agent preparing a vendor payment run might read invoices, check balances and stage payments. Reading invoices is routine. Releasing the payment run isn't, and it deserves its own decision, possibly with a person approving it first. 

Per-Transaction Access Checks Still Need to Solve for Standing Privileges 

A per-transaction check decides whether a request may proceed, but the account, role, key or token behind that request usually exists before the request and after it. Checking each request reduces standing exposure, but unless the access is dynamically assigned and revoked, it doesn't remove standing privileges entirely. 

Per-transaction authorization is a clear step past static authorization, where a role check alone lets a valid account or token do anything the role allows inside an approved session. Verifying authorization at each request narrows what that account can do through the path the check sits on. 

If access is still available, even when it isn’t being utilized, it can still be used in three ways: 

  • The decision point is bypassed. A credential that works against the resource directly doesn't have to go through the policy check at all. 
  • The policy is too coarse. A rule that approves "database writes" approves potentially harmful write changes along with the routine ones. 
  • The context is out of date. A check that relies on stale signals approves requests that the current situation wouldn't support. 

There's a fourth gap specific to agents. An approved tool call can carry a SQL query or a shell command that the tool passes straight to the resource. The check approved the call. It never saw the command inside it. 

So the useful test isn't whether each request gets a decision. It's what remains once the request is done: after the request is approved and finished, what still exists in the target system? If the answer is a role, a key or a session that works without another decision, per-transaction authorization has narrowed the risk. It hasn't removed it. 

That's why per-transaction checks belong on top of zero standing access, not on top of static grants. 

What Does Per-Transaction Authorization Look Like Without Standing Access? 

The decision and the privilege arrive and leave together. The request is evaluated when it's made, the privilege it needs is created for that task, enforcement reaches down to the command, and the privilege is removed when the task ends. Between requests, there's no standing access left to use or steal. 

This changes what a bypass is worth. If the account behind a request holds no privileges until a request is approved, going around the decision point gets an attacker nothing. A stolen credential opens an account that can't do anything. 

It also creates two moments that a session can't offer. A person can approve sensitive access before it exists, rather than reviewing what happened after. And a command can be blocked after access was approved, because approval of the request doesn't mean approval of everything sent through it. Add a third: when an identity provider or security tool reports a compromised credential or a risky device, access that's already in use can be revoked mid-task instead of at its next expiry. 

How Britive Applies This Model Across Identities 

Britive applies the same model to agentic AI, non-human identities and humans, on one policy engine: 

  • Every AI agent tool call gets a decision. The Britive MCP Gateway authorizes every tool call, with default deny. The gateway doesn't decide on its own; the Britive platform is the decision authority. Sensitive tool calls are blocked until a person approves them. 
  • Every identity gets access for the task, then loses it. Agents, pipelines and people check out access under policy for the task at hand, and it's removed when the task ends. Where possible, Britive raises permissions inside the target system's own access model, with no privileged credential issued, and reverses the change afterward. 
  • Agents never hold the credential. Credentials are held by the Britive platform and injected for a single call. 
  • Commands are checked too. Where sessions run through Britive's session and command enforcement, commands are blocked before they reach the resource. 
  • Signals cut access mid-task. When an identity provider or security tool sends a CAEP or RISC signal, Britive can revoke an active checkout before the task finishes. 
  • Each action leaves a record. Every tool call is recorded with the identity behind it, the prompt and arguments, and the model's stated reason for choosing the tool where the agent's client provides it. 

One boundary is worth stating plainly. Britive controls the access a request runs on. Rules about the business content of a request, such as a payment amount or a recipient, belong in the application that holds that data. The two work together: the application decides whether the payment makes sense, and Britive decides whether the identity holds any access at all. 

Analyst firm SACR put the model in one line in its ARISE report: "Britive's clearest moat is the just-in-time, zero-standing privilege model applied across identity types." Read SACR's assessment. For one customer's version of the shift, see how Marqeta traded JIT on paper for runtime access enforcement. 

How Does Per-Transaction Authorization Fit With Runtime Authorization, JIT and Zero Standing Privileges? 

Runtime authorization is the model: access is decided when it's requested, not in advance. Just-in-time is about when access is granted. Per-transaction describes how narrow each decision is. Zero standing privileges is the result when access exists only for the request in front of it, and for no time beyond it. 

The four terms get used interchangeably, and they shouldn't be, because you can have one without the others. A just-in-time grant can still sit on standing access when it unlocks an account that's privileged all the time, which is why not all JIT eliminates standing access. A per-transaction check can still sit on a static role. And a single decision at the start of a long session isn't continuous authorization, however short the session. 

Put together, they describe one approach. Runtime authorization decides each request as it arrives. Per-transaction granularity keeps each decision to a single request. Just-in-time timing creates the privilege only when it's needed. Zero standing privileges is what's left between requests: nothing. 

Assess Whether a Model Authorizes Access for Each Transaction 

Ask three questions of any access model, including the one you run today. The answers show whether each request gets its own decision, whether people and policy can step in at the right moments, and whether anything is left behind once the work is done. 

  1. When the model verifies an identity, what does that verification decide? The single request in front of it, or a session that covers everything after? 
  2. Can a person approve sensitive access before it exists, and can a command be blocked after access is approved? A model that decides once per session can't do either. 
  3. After the request is approved and finished, what still exists in the target system? An account with no privileges, or a role, key or token that's ready for the next use, whoever ends up using it? 

Ask them of your AI agents first, since they make the most requests with the least oversight. Then ask them of your service accounts and pipelines, and then of your administrators. In many environments, the answer to the third question is the same for all three.