DPO Radio

A compliance team issuing keys for multiple external integrations has a recurring failure mode: a key issued for one purpose drifts into a broader one, and the broader use exceeds what the key holder was ever authorised to do. The fix is layered scoping — the key's own whitelist, plus the underlying permissions of the user the key represents — applied at every call.
The Forseti permission model is layered by construction. The tool whitelist on the API key is the first gate; tools outside the whitelist return a scope-mismatch error before any handler runs. The second gate is the API-key holder's permission set, resolved at call time. Even if the key whitelists a tool, the underlying operation only executes if the key holder has the corresponding permission on the record type.
The layering eliminates the most common out-of-band-escalation pattern. Revoking a permission from a user revokes it from every key that user issued. There is no "this key was created when I had permissions, so it should keep working" exception. The platform resolves permissions at the moment the call (or the approval) executes.
Every key carries its own tool whitelist that names which Forseti tools the key may call. The whitelist is set at issuance and locked unless the administrator rotates the key. Tools outside the whitelist return a scope-mismatch error before any handler runs.
When a tool runs, the platform resolves the API-key holder's permission set at that moment. The key represents a specific administrator at issuance time; the resolved permissions are that administrator's current permissions. Even if the key's whitelist names a tool, the underlying operation only executes if the key holder has the corresponding permission on the record type.
Read tools resolve both gates synchronously at the call boundary. Write tools resolve the tool-whitelist gate at the call (proposal enqueue) and the permission gate at the approval-queue execution. If the key holder's permissions change between proposal and approval, the approval reflects the current state.
The tool-list response is the intersection of the key's whitelist and the tool set the Forseti MCP surface defines — nothing widens it. There is no tier-scoped tool set and no organisation-level tool toggle: the package a customer buys does not change the tool surface. The whitelist is validated against the platform tool set at issuance, so a tool the platform does not expose — a deletion tool, for instance — cannot be placed on a key at all.
Revoking a permission from the key holder revokes it from every key that holder issued. There is no path for a key to retain a permission its holder no longer has. The approval-queue execution layer resolves permissions at execute-time, not at issue-time, so historical permission state cannot be replayed.
The organisation identifier is resolved from the API key row at authentication, not from any client-supplied claim. There is no path for a caller to address another organisation's records, regardless of the tool whitelist or the key holder's permissions.



The tool whitelist is the first gate at every call. Tools outside the whitelist never reach a handler; the scope-mismatch denial is recorded with the proposing key prefix and the requested tool.

Permission resolution happens at execute-time, not at issue-time. An offboarded administrator's keys lose the offboarded permissions automatically. The audit event records the resolved-permission state at the moment of execution.

Cross-organisation calls are impossible by construction. The organisation identifier is resolved from the API key row, not from any client-supplied claim. There is no path for a caller to address another organisation's records regardless of the tool whitelist or the underlying permission set.

An OAuth connection is checked against the authorised scope, registered client's tool list and the granting user's current access. An API key is narrowed to its allowed tools and issuing role. Write proposals still require a human decision.
Ready to see two layered gates run at the call boundary and the audit event record both? Request a personalised demo.


Issue a key, narrow its whitelist, and run a 30-day pilot. Use the audit trail to verify the layered scoping behaves as expected against your permission model.

Talk to our team about how to scope keys for least-privilege integrations across your existing administrator permission structure.
The first layer is the tool whitelist on the API key — a list of tool names the key is permitted to call. Tools outside the whitelist return a scope-mismatch error. The second layer is the API-key holder's permission set, resolved at call time. Even if the key whitelists a tool, the underlying operation only executes if the key holder has the corresponding permission on the record type.
The revocation propagates to every key that user has issued. The platform resolves permissions at execute-time, so subsequent calls (or subsequent approvals for queued write proposals) reflect the current state. There is no path for a key to retain a permission its holder no longer has.
The protocol allows it — the platform does not enforce per-user binding. But the audit trail shows every call against the key's recorded administrator identifier, not the calling user. The recommended pattern is one key per integration (not per human) and rotation on operator turnover.
The call fails with a clear "permission denied" response. The denial is recorded in the audit trail with the requesting key prefix, the tool, and the missing permission. For write tools, the failure surfaces on the approval-queue side rather than the call-time side because permission resolution happens at execute-time.
No. There are no organisation-level tool toggles, and no tier-scoped tool set. The tool-list response is the intersection of the key's whitelist and the tool set the Forseti MCP surface defines. The second gate — the key holder's own permission set — is applied when a tool runs, not when the list is fetched. Scoping is therefore done at issuance by choosing the key's whitelist, and undone by revoking the key or the holder's permissions.