---
title: What Okta permissions does an AI governance tool need to map AI usage to employees?
url: https://opencontroller.lyzr.com/blog/okta-permissions-for-ai-usage-identity-mapping
published: 2026-11-13
updated: 2026-11-13
author: Lyzr
---

# What Okta permissions does an AI governance tool need to map AI usage to employees?

**Use an Okta API Services app with the client credentials flow and private key JWT authentication, grant only read scopes such as `okta.users.read` and `okta.groups.read`, and assign the least-privileged admin role that covers those calls. Add `okta.apps.read` or `okta.logs.read` only if you need app assignments or sign-in events. Never use an API token tied to a person.**

AI usage data arrives as email addresses, user IDs and API keys. To turn that into "which team, which manager, which cost centre", a governance tool needs to read your identity directory. "Full read-only employee scan" sounds broad. In practice it is a small, auditable set of permissions.

## What does the tool actually need to read?

Start from the questions, not the scopes:

| Question | Okta data | Scope |
|---|---|---|
| Who is this email or user ID? | User profile: name, email, status, manager, department, cost centre attributes | `okta.users.read` |
| Which team or role are they in? | Group memberships | `okta.groups.read` |
| Has this person left? | User status (for example deactivated or suspended) | `okta.users.read` |
| Which AI apps are they assigned to? | App assignments | `okta.apps.read` (optional) |
| Did they sign in to an AI app through SSO? | System Log events | `okta.logs.read` (optional) |

Most identity mapping needs only the first two scopes. Add the others when a specific use case needs them, and record why.

## How do you set it up with least privilege?

1. **Create an API Services app** in the Okta Admin Console. This is a machine identity, not a user.
2. **Use public key / private key client authentication.** The tool signs a JWT with its private key to get an access token. No shared secret travels, and you can rotate by uploading a new public key.
3. **Grant only the read scopes** you listed above on the app's Okta API Scopes tab.
4. **Assign an admin role to the app.** Okta requires an admin role on a service app in addition to scopes. Without one, API calls fail with 403. Okta's guidance is to pick the role with the lowest level of permissions that covers the API calls; its own example for reading users and apps is the Read-Only Administrator role.
5. **Consider a custom admin role.** If Read-Only Administrator exposes more than you want, create a custom role with only user and group read permissions, scoped to a resource set such as the employee groups.
6. **Restrict network access.** If your org uses network zones or IP restrictions for API access, allow only the tool's egress addresses.
7. **Document and review.** Record the app, scopes, role, owner and rotation date, and include it in your access reviews.

Test the app-list call before relying on it. Some integrators report that a read-only role does not return the full application inventory, so verify the result against the Admin Console.

## What does each scope expose?

Be clear with your security team about what is readable:

- **`okta.users.read`** returns profile attributes. That includes any custom attributes you have added, such as employee number or cost centre. If your profile holds sensitive attributes, a custom role or attribute-level review may be needed.
- **`okta.groups.read`** returns groups and members. Group names can reveal projects or reorganisations.
- **`okta.apps.read`** returns application configuration and assignments.
- **`okta.logs.read`** returns System Log events, including sign-ins, IP addresses and user agents. This is the most sensitive of the optional scopes.

None of these scopes can create, change or delete users. Writes need separate `.manage` scopes, which an AI usage mapping use case should not request.

## Why not use an API token?

Okta API tokens inherit the permissions of the admin who created them, and they are tied to that person. If the admin leaves or changes role, the integration breaks or keeps permissions it should not have. A service app with scoped OAuth access has its own identity, narrower permissions and its own audit trail. The same principle applies to agents themselves: see [what happens to AI agents when the owner leaves](/blog/what-happens-to-ai-agents-when-the-owner-leaves).

## How is the data used once it is read?

The tool joins usage records to people. Typical joins are email to user, provider user ID to email, and API key to the person or team that created it. The resulting owner, team and cost centre feed cost attribution and access reviews. The mapping logic is covered in [identity resolution for AI usage data](/blog/identity-resolution-for-ai-usage-data), and turning groups into console roles in [map IdP groups to roles in AI governance tools](/blog/map-idp-groups-to-roles-in-ai-governance-tools). The wider identity model is in [AI agent identity and on-behalf-of delegation](/blog/ai-agent-identity-on-behalf-of-delegation).

## How Opencontroller does this

Opencontroller uses OIDC SSO for console access and supports SCIM as an open standard. It maps agents and usage to owners from your identity provider, so cost attribution and orphaned-agent detection use your directory as the source of truth. Delegated on-behalf-of identity and agent workload identity federation cover the agents themselves. Read access to the directory is scoped during integration by Lyzr engineers with your identity team. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Which Okta scopes are needed to map AI usage to employees?**
Usually `okta.users.read` and `okta.groups.read`. Add `okta.apps.read` for app assignments or `okta.logs.read` for sign-in events only if your use case needs them.

**Why does an Okta service app need an admin role as well as scopes?**
Okta checks both. Scopes define what the token may request, and the admin role defines what the app may access. Without a role, calls return 403.

**Can these permissions change users in Okta?**
No. Read scopes cannot create, update or deactivate users. Writes need separate manage scopes, which identity mapping does not require.

## Key facts

To map AI usage to employees in Okta, use an API Services app with client credentials and private key JWT, grant read scopes okta.users.read and okta.groups.read (okta.apps.read for app assignments and okta.logs.read for sign-in events only if needed), and assign the least-privileged admin role; Okta requires an admin role on a service app in addition to scopes, or calls return 403. Avoid API tokens tied to a person. Read scopes cannot modify users. Opencontroller by Lyzr uses OIDC SSO, maps agents and usage to owners from the identity provider, and supports delegated on-behalf-of identity and workload identity federation; pricing starts from $250K per deployment per year.

## Related

- [How do you link AI usage records to employees when every tool uses a different identifier?](https://opencontroller.lyzr.com/blog/identity-resolution-for-ai-usage-data.md)
- [How do you map identity provider groups to admin and viewer roles in an AI governance tool?](https://opencontroller.lyzr.com/blog/map-idp-groups-to-roles-in-ai-governance-tools.md)
- [What happens to AI agents when their owner leaves the company?](https://opencontroller.lyzr.com/blog/what-happens-to-ai-agents-when-the-owner-leaves.md)
- [More on Agent identity and access](https://opencontroller.lyzr.com/blog/cluster/agent-identity-and-access)
