Roles & access control — in depth¶
Use this reference to provision the right identity on the right system. It covers the TrackMe user, the scheduled owner, the Splunk source reader and any additional API account, with separate requirements for UAM, Splunk HEC, Splunk S2S, Splunk UF Fleet, Splunk Forwarder Collectors, Cribl Stream and Cribl Edge. For the shorter setup guide, start with Roles & access control.
How TrackMe RBAC works¶
TrackMe combines capabilities, tenant scope and Splunk object/index permissions:
A capability authorizes an operation. The user’s effective capabilities include grants inherited through Splunk roles.
The tenant’s admin, power and user role lists determine which tenants the user can administer, operate or read. Higher-level access includes the lower-level operations.
Splunk ACLs protect the tenant’s knowledge objects. Index permissions govern searches of its results and of source data. A capability does not replace index access.
TrackMe authorizes a caller before performing privileged work on their behalf. A successful UI operation does not mean the caller’s own search session, a scheduled owner, or a remote token can perform every underlying read directly.
The built-in roles¶
Role |
Capability |
Tenant operations |
|---|---|---|
|
|
Read the tenant’s monitoring results, subject to the component’s access rules. |
|
|
Operate existing monitoring. In HEC, S2S, UF Fleet, Forwarder Collectors, Stream and Edge: triage findings and Finding groups, assign, annotate and use permitted actions. |
|
|
Create tenants and trackers; administer source settings, policies, collection and automation for tenants in the user’s admin scope. |
trackme_power inherits trackme_user; trackme_admin inherits trackme_power.
Membership and inheritance both work. If you grant capabilities directly instead, include
all the levels the role needs. On the six findings workspaces above, read access accepts
any tenant role, triage requires a power or admin role, and configuration requires an admin
role, in addition to the matching capability. admin / sc_admin and Splunk’s
internal execution context have administrative access.
UAM is different: its workspace requires tenant-administrator access. Its limited power access is through selected REST operations; a tenant user has no UAM access. See UAM: audit access and per-tier inventories for the complete distinction.
The scheduled owner and service account¶
A tenant’s owner owns its reports and scheduled monitoring. It is set at creation and can be changed through the tenant’s RBAC/ownership controls. A service account is simply a named Splunk user chosen for that role; it is not the person currently viewing the tenant, nor automatically the user behind any remote token.
nobody and a named owner¶
``nobody`` is supported for ordinary collection. It is a knowledge-object ownership value: Splunk supplies the scheduled execution identity. It is not a remote username or a credential to create on another system. Source/API authorization still applies.
A named owner must be able to run the scheduled work and access its inputs. Configure its permissions on the TrackMe search tier, then separately configure every remote user and Cribl credential it uses.
Scheduled AI Agents require a named owner.
nobodyandsplunk-system-userare rejected for scheduled agent execution. The named owner also needs the agent’s tenant access and access to the records the agent uses; changing the owner is not itself proof that an agent run will succeed.splunk-system-useris not a selectable replacement for a named owner in the HEC/S2S/UF Fleet/Forwarder Collectors/Cribl creation flows.
Current owner capability checks¶
For Splunk HEC, Splunk S2S, Splunk UF Fleet, Splunk Forwarder Collectors, Cribl Stream and
Cribl Edge, the current
creation and collection checks accept nobody, a member of admin / sc_admin, or
an account holding all seven of these capabilities:
Capability |
Scope |
|---|---|
|
TrackMe user operations |
|
TrackMe power operations |
|
TrackMe administration operations |
|
Scheduled searches |
|
Splunk settings reads |
|
Splunk credential-store reads |
|
Splunk knowledge-object administration |
This is an enforced owner requirement, not a claim that every individual collection
read needs all seven. They may be inherited or granted directly. Add search and the
source/result index permissions needed by the work; the owner check alone does not verify
search coverage. A custom owner role can inherit trackme_admin and power and add
the remaining required capabilities, but it is still a privileged role.
The general Configuration Guardian check ``insufficient_tenant_owner_capabilities``
uses this same seven-capability list for named owners of enabled tenants, including UAM.
UAM’s own collection preflight is narrower: it checks the identities and capabilities
in UAM: audit access and per-tier inventories and does not require list_settings or list_storage_passwords
for those reads. A successful UAM collection check therefore does not necessarily clear
the general owner warning. Diagnose the named check rather than combining the two lists
into a requirement for every remote UAM account.
Important
Keep owner permissions separate from user and remote-account permissions
Do not copy this seven-capability set onto every TrackMe user, or onto a cluster manager or Deployment Server reader. The first needs the relevant tenant role; the latter need their destination-specific reads. Their requirements are listed below.
Local searches, remote searches and API accounts¶
A search tier is the search head or search head cluster that dispatches searches. It
may search distributed indexers; choosing local does not mean the data must be stored
on the TrackMe search head.
Read |
Acting identity |
Access to check |
|---|---|---|
Scheduled local search |
Named tenant owner, or Splunk’s execution context for |
Search and index permissions on the TrackMe search tier |
Scheduled remote search |
The owner starts the work; the destination search runs as the remote token user |
The owner’s effective roles may use the TrackMe remote account; the token user may search the destination’s indexes and perform the required REST reads |
Additional Splunk API read |
Token user of the selected HEC, cluster manager or Deployment Server account |
That system’s endpoint permissions; these can differ from the telemetry source |
Cribl API read |
Cribl.Cloud API client or self-managed Cribl user in the Cribl connection |
Cribl product, group/Fleet and API read permissions |
Interactive search or live fetch |
The caller, or the remote token selected for that action |
The caller’s source/result index access and permission to use the remote account when applicable; do not infer these from a successful schedule |
Remote-account RBAC is configured on TrackMe. Its rbac_roles allows local roles to
use the stored account. Inherited roles count. For HEC, S2S, UF Fleet and Forwarder
Collectors, creation/settings
check that the selected owner may use the source and enrichment accounts; an explicit
refusal is reported as remote_account_refused. UAM also checks account use for its
collection and live reads. Internal scheduler handling does not grant additional
capabilities to the destination token.
Destination permissions are configured on the destination. A token authenticates a
Splunk user on that system. Grant that user the required capabilities and index access
there. Giving the local owner list_indexer_cluster cannot repair a remote source token
that lacks it. TrackMe need not be installed on a remote telemetry tier merely to run
Splunk searches; UAM’s remote administrative check has a specific consequence when the
TrackMe capability is absent (see below).
The account’s endpoint matters. The telemetry source usually points to a search head. A cluster manager account must point to the manager; a Deployment Server API account to the Deployment Server; HEC enrichment to the endpoint’s splunkd management API. They are independent account selections, even when some use the same user or system.
Source indexes and TrackMe result indexes¶
Grant index access to the identity that actually searches on that tier. The source index names below are defaults; use the configured names when they differ.
Component |
Indexes |
Reader / condition |
|---|---|---|
UAM |
|
The route account that searches audit, resource and indexer activity. Inventory accounts on other tiers have separate REST/object requirements. |
Splunk HEC |
|
Owner for a local source; token user for a remote source |
Splunk S2S |
|
Source reader. Keep |
Splunk UF Fleet |
Telemetry: |
Telemetry reader and Deployment Server source reader can be different accounts on different systems. The optional DS API user also needs the three DS indexes. |
Splunk Forwarder Collectors |
|
Owner for a local source; token user for a remote source |
Cribl Stream |
The configured Cribl internal-metrics index, for example |
Local TrackMe execution identity; no remote metric-source account |
Cribl Edge |
Optional configured System Metrics index |
Local TrackMe execution identity, for node CPU and memory. Core API monitoring does not depend on a Splunk source index. |
TrackMe result indexes are a second set. The tenant’s summary, audit, metric and
notable indexes store TrackMe’s own results. Give the people investigating the tenant
access to the results they need, and ensure the scheduled owner can use the configured
stores and searches. These indexes are not the same as Splunk’s _audit or source
_metrics. When results are on another deployment, follow the tenant’s configured
storage/search arrangement as well as its source arrangement.
``*`` does not include internal indexes. In a Splunk role, srchIndexesAllowed = *
covers ordinary indexes, not names beginning with _. Grant the required internal
indexes explicitly; _* grants all internal indexes and is broader. Search filters and
explicit disallowed indexes can still restrict visibility. See the
Splunk authorize.conf reference.
For example, a remote HEC telemetry reader can inherit basic search capabilities and be restricted to its two source indexes:
[role_trackme_hec_telemetry]
importRoles = user
srchIndexesAllowed = _internal;_introspection
This is a source-reader example, not the complete role for a named TrackMe tenant owner. Check the user’s other inherited roles too: this stanza does not revoke broader access already granted elsewhere. Index permission also cannot make data visible if it was never forwarded to the indexers searched by that tier.
UAM: audit access and per-tier inventories¶
UAM separates the route account, which searches the audit/resource data, from the inventory accounts, which read users, roles and knowledge objects on each search head tier. One tier can serve both purposes. Do not assume that a search head holding all the audit data can also enumerate another tier’s local users and private objects.
Who may use UAM¶
Caller |
Access |
|---|---|
Splunk administrator with |
Administrative access across UAM tenants |
|
UAM workspace, configuration, collection, policies and decisions |
|
Selected REST read operations, user communications and findings actions; no UAM workspace |
Tenant user |
No UAM access |
Workspace searches and live Fetch SPL / Fetch definition operations can use the caller’s own access. The user needs the relevant TrackMe/source indexes and, for a remote fetch, permission to use that remote account. An owner collecting successfully does not grant these rights to the person investigating.
Collection-account requirements¶
Capability / access |
Local tier: named owner |
Remote tier: token user |
|---|---|---|
|
Required |
Required |
|
Required; with TrackMe admin access, the owner also needs a tenant admin role |
Required. Without TrackMe installed there, |
|
Not needed for the local identity catalogs: TrackMe’s authorized identity reader performs those reads |
Required to enumerate all users and roles. |
|
Required for a search head cluster |
Required for a search head cluster |
Source index access |
|
The same indexes when this is the route account |
Knowledge-object / lookup access |
Determines which objects and definitions are visible |
Determines which objects and definitions are visible; REST access alone does not guarantee all private objects are visible |
Before Splunk 10.4, UAM also reads admin/file-explorer for CSV lookup sizes; that read
must be allowed on each inventory tier for lookup-footprint coverage, and a least-privilege
account is refused it by default. A refused read is shown as Lookup sizes refused. From
Splunk 10.4 the lookup listing reports the size, with no extra access. Granting list_all_users does not solve an unrelated
lookup-size or object-ACL refusal.
The UAM collection check does not require list_settings or list_storage_passwords.
It runs at tenant creation and through Configuration Guardian, which reports UAM
collection permissions need attention with the affected tier. It checks capabilities,
not complete data coverage: ``identity_visibility_limited`` means the user/role
catalog still reflects only the reading account. See UAM collection accounts
for collection details and The scheduled owner and service account for the separate general owner check.
Splunk HEC: telemetry and optional configuration reads¶
The telemetry reader needs search and access to _internal and
_introspection on the selected source tier. For local, this is the scheduled
execution identity; for a remote source, the remote token user. The owner must be allowed
to use the remote account. These searches support monitoring without management access to
individual HEC endpoints.
Optional splunkd API accounts add HEC token consistency and the HEC-settings portion of configuration drift. Each account points to the endpoint’s management port, not the HEC ingestion port, and uses a Splunk authentication token, not an HEC ingestion token. The owner must be allowed to use each of these accounts independently of the source account.
The destination user must be allowed to GET:
/services/server/info;/services/data/inputs/http/http(global HEC settings);/services/data/inputs/http(HEC input configuration).
Splunk defines ``list_token_http`` for viewing HTTP token-input settings; use that read
capability where supported by the target version and check that the account can read all
three endpoints. edit_token_http is broader: it also allows changes. TrackMe performs
GETs only, but that does not turn a broadly privileged token into a read-only credential.
The capability definitions are in the
Splunk authorize.conf reference.
The exact minimum for this three-endpoint combination is not established by TrackMe’s
capability preflight; verify the reads on the target Splunk version instead of applying
the owner capability bundle to the endpoint user.
HEC token values are discarded while parsing the response. If an enrichment read is refused, Collection health reports the affected account; telemetry monitoring continues. On Splunk Cloud, customer access to the indexers’ management API is not used by this enrichment. Monitor Cloud HEC through the source search tier’s internal indexes. See Splunk HEC for the complete workflow.
Splunk S2S: two levels of indexer-cluster access¶
Telemetry uses the source-reader permissions in Source indexes and TrackMe result indexes, plus the named owner requirements on TrackMe. Cluster discovery adds a requirement on that source reader, even when no cluster manager account has been configured.
Read |
Account and capabilities |
What it adds |
|---|---|---|
Search head’s cluster view |
Local owner or remote source token user: |
|
Optional manager view |
Cluster manager account’s token user, on the manager:
|
Manager configuration, maintenance/rolling-restart state and peers from
|
A missing source-reader list_indexer_cluster can appear as no rows from | rest.
TrackMe reports ``cluster_read_refused`` rather than treating that as an empty cluster.
For a deployment without an indexer cluster, Indexer clusters as pools → Off disables
that discovery; it is not a fix for a clustered deployment with missing access.
The optional manager account is configured per cluster pool, and its local account RBAC must allow the owner. TrackMe recommends this read-oriented role on the manager:
[role_trackme_cluster_reader]
importRoles =
search = enabled
rest_properties_get = enabled
list_indexer_cluster = enabled
This is the capability set recommended by the product’s account check, not a certified
minimum for every Splunk release. Check all three manager reads in the wizard or Settings;
the result identifies refused reads. edit_indexer_cluster is not part of the
recommendation: TrackMe observes the cluster and does not change its configuration.
Without a manager account, the search head’s cluster view remains available. A failing manager account is reported as ``cluster_manager_unreadable``; manager-specific facts are unavailable and maintenance handling relies on the search head’s view. It does not remove the source reader’s own cluster-read requirement.
Splunk UF Fleet: three independent access paths¶
UF Fleet can read its forwarding telemetry, Deployment Server event data and Deployment Server API from different systems. Configure all the paths you use, even when they happen to share a credential.
Selection |
Required access |
Purpose |
|---|---|---|
Source |
Local execution identity or remote source token: |
Receivers’ connection records, agent logs and resource observations |
Deployment Server source |
Local execution identity or its own remote token: |
Phonehomes, client properties and app-deployment events |
Deployment Server API accounts — optional |
On each Deployment Server: |
Read |
The Deployment Server source is a search location, separate from the main telemetry source. When the DS indexes are searchable on the TrackMe tier, it can be local. Otherwise choose a remote account on the tier that holds them. In particular, when the main source is Splunk Cloud and the DS data remains on an on-premises Deployment Server, select a remote account on that Deployment Server for the DS source.
The optional DS API account is a separate selection. Adding it does not change where telemetry or DS events are searched. Without it, server-class groups use clients observed in app events over the last 60 days, labelled App events (60 days); this is not a complete current client listing, and its coverage is not judged as such.
Important
An HTTP 200 with no clients can be an index-permission problem
The Deployment Server builds its client listing from searches of _dsphonehome,
_dsclient and _dsappevent as the API caller. list_deployment_server alone
can therefore return an empty listing. Grant the API user access to these indexes
on the Deployment Server, even if another account already searches copies on your
indexers. Splunk documents this behaviour in
Deployment clients are not visible for non-admin users.
A dedicated DS API reader role can be:
[role_trackme_ds_reader]
importRoles =
search = enabled
rest_properties_get = enabled
list_deployment_server = enabled
srchIndexesAllowed = _dsphonehome;_dsclient;_dsappevent
This does not need a Splunk administrator role or Deployment Server edit capabilities. If the same account also serves the DS telemetry source, add whatever other indexes that source reads. If it also serves the general telemetry source, add those indexes too.
The wizard and Settings check the selected DS API account’s identity, capabilities and client listing. If the listing is empty they also check visible phonehomes. No phonehomes can mean missing index access or no recent data; if phonehomes are visible, a clustered Deployment Server may have another member that serves the listing. Check the member and the actual data rather than treating an empty response as proof of a healthy empty fleet.
Expected-agent and group lookup tables introduce another read: the scheduled owner needs the lookup’s ACLs locally, or permission to use the chosen remote lookup account, whose user must be able to read the lookup there.
Splunk Forwarder Collectors: the source and optional collector accounts¶
Telemetry uses the source-reader permissions in Source indexes and TrackMe result indexes: the collectors
forward their _internal, _introspection and _configtracker to indexers the source
search tier can read, which is Splunk’s default forwarding of internal indexes. Every policy
works from this telemetry alone.
Selection |
Required access |
Purpose |
|---|---|---|
Source |
Local execution identity or remote source token: |
Each collector’s metrics and logs, its processes and disks, and its configuration changes, which list the inputs it has |
Collector API accounts — optional |
On each collector: |
The current list of the collector’s inputs and their state, read from its management API |
The optional collector API account is a TrackMe remote account on the collector itself. The wizard and Settings check each one as it is added: who the account is, which instance answers, and how many inputs it reads; a missing capability is named with the read-only role that fixes it. A failing account can still be chosen, because no policy depends on it. A Splunk Cloud search tier usually cannot reach a customer’s collectors: the tenant then works from the telemetry, and an input appears from its configuration changes or while it delivers.
A dedicated collector reader role can be:
[role_trackme_collector_reader]
importRoles =
search = enabled
rest_properties_get = enabled
list_inputs = enabled
The scheduled owner must be allowed to use the source account and every collector API account the tenant reads, like the other Splunk dedicated tenants.
Cribl Stream: local metrics plus a Cribl connection¶
A Stream tenant has two required inputs with different credentials:
Cribl internal metrics in a Splunk metric index searchable from the local TrackMe tier. The scheduled execution identity needs
searchand access to that index. The index may be on distributed indexers, but the current Stream metric source islocal; a TrackMe remote metric-source account is not supported.A Cribl connection to Cribl.Cloud or the self-managed Leader. This uses a Cribl API client/user, not a Splunk user or a Splunk remote-deployment account.
The Cribl credential needs read access to the selected Worker Groups and Workers, Sources, Destinations, Pipelines, Routes and Packs, Leader system information, and Leader-proxied Worker system information and input/output status. Scope it to the groups being monitored while allowing those reads. TrackMe does not prescribe a universal Cribl role name; permissions depend on the Cribl deployment and its role model.
Both inputs matter: successful Cribl authentication does not grant access to the Splunk metrics index, and a metrics search succeeding does not prove inventory/status API coverage. Configure the named owner’s capabilities separately using The scheduled owner and service account. See Cribl Stream and What the Cribl account needs for setup and connection details.
Cribl Edge: API monitoring and optional System Metrics¶
Edge’s core monitoring reads the Cribl Leader API through a Cribl connection. The credential needs read access to the selected Fleets and Edge Nodes, their Source and Destination configuration, Leader system information, and Leader-proxied node status, system information and system metrics. This is a Cribl permission grant; adding Splunk capabilities to a remote Splunk user does not provide it.
A Splunk source index is not required for core API monitoring. For node CPU and memory policies/charts, configure the optional System Metrics index and grant the local TrackMe execution identity search access to it. A remote metric-source account is not supported. Without this index, the relevant features report that System Metrics are needed; that does not mean the Cribl connection has failed.
The tenant still has its own TrackMe result stores and scheduled-owner requirements. For both Stream and Edge, a Splunk administrator manages the stored Cribl connection; tenant users operate the workspace through their TrackMe role without being given the Cribl credential. All monitoring reads leave Cribl configuration unchanged. See Cribl Edge and What the Cribl account needs.
Validate each identity and diagnose the missing layer¶
Record the account map. Note the tenant owner, local/remote source, optional API accounts, and the actual user behind each remote token. For UF Fleet, record the Deployment Server source separately. For UAM, record the route and every inventory tier.
Check local entitlement. Verify the operator’s TrackMe capability and tenant role, and the scheduled owner’s required capabilities. Verify permission to use each selected remote account for the owner and for users making live remote reads.
Check the destination identity. Test connectivity in the native account-management UI, then run the component’s account/collection checks. A valid token is not proof of cluster access, a complete user catalog, or access to the source indexes.
Check data visibility as the reader. Confirm that known recent events or metric series are visible in the configured indexes and time range, with the required host scope. Check lookup/object ACLs too. A test performed as your administrator account does not test the token user’s or the owner’s visibility.
Check a scheduled run. Use Collection health and Configuration Guardian to confirm successful, recent collection after the changes. Manual collection can be dispatched after privileged authorization and can succeed where the scheduled owner fails.
Check the intended user experience. Sign in as a scoped user/power/admin account and verify the tenants, results and operations each should see. For UAM, verify its stricter workspace boundary. If scheduled AI is enabled, verify an actual agent run under its named owner as well.
Symptom |
Check first |
|---|---|
Tenant missing or an action forbidden |
TrackMe capability, tenant role lists, inherited roles and the username allowlist |
|
The named owner’s general seven-capability requirement on TrackMe; do not add these capabilities to every remote account |
Manual collection works; scheduled collection fails |
The owner, its remote-account use, source/result index access and collection receipt |
|
Local permission to use the account, distinct from destination token permissions |
UAM catalog contains only the reader |
Remote |
|
|
|
The separate manager account, its destination, connectivity and three manager reads |
DS API returns no clients |
The API user’s |
Source search succeeds but returns no expected data |
Allowed/disallowed indexes, search filters, forwarding, retention, host scope and correct search tier; transport success alone does not establish coverage |
Cribl API works but traffic or CPU charts are empty |
Stream metrics-index access or Edge’s optional System Metrics configuration and data |
Scheduled AI Agent reports a system owner |
Reassign to a named owner with the required tenant and automation access |
Configuration-UI requirements¶
TrackMe provides native interfaces under Configuration, replacing the Splunk UCC
configuration page. System settings and account management require a Splunk
administrator-class user with TrackMe admin capabilities, typically trackme_admin
together with admin / sc_admin. A denied request produces an Insufficient
permissions message.
System settings → General → Knowledge objects & RBAC defaults sets the proposed owner, sharing and roles for new tenants.
Manage Remote deployment accounts manages Splunk source/API connections and their account RBAC. Manage Cribl connections manages Cribl API credentials and scope.
Manage Email delivery accounts, Manage S3 export accounts and Manage Webhook accounts manage the other integrations.
An existing tenant’s roles and owner are changed through its Virtual Tenant UI, as described below. These changes are separate from system-wide defaults.
See Configuration and System settings.
RBAC at tenant creation¶
RBAC and ownership are defined as part of creating a Virtual Tenant.
Hint
Preset the creation defaults
You can preset the proposed owner and roles for new tenants under Configuration → System settings → General → Knowledge objects & RBAC defaults.
See System settings for the native configuration interface. These defaults do not change the permissions of existing tenants.
Defining RBAC while creating a tenant:
Once the tenant exists, you can review the permissions and ownership TrackMe applied:
Worked example: per-team tenant access¶
This example shows how to scope access to Virtual Tenants by role. We have three tenants, each dedicated to a regional security-operations team:
secops-emea— EMEA team, Splunk rolesecops_emeasecops-amer— Americas team, Splunk rolesecops_amersecops-uk— UK team, Splunk rolesecops_uk
The administrator in this example is granted admin access to all three tenants. Each team receives its own scoped role for access:
Each role must also be granted access to the TrackMe application namespace:
Warning
Inheritance can over-grant access
By default, a new tenant lists all three built-in roles in each RBAC category. So if the role you use for access inherits from one of the built-in roles and you leave that default in place, its members are granted access and will see every tenant. To scope access cleanly, either make the desired TrackMe capability native to the user’s role, or remove the built-in roles from the tenant’s RBAC configuration.
When a member of the configured roles connects, they see only the tenants they have access to:
If a user is granted TrackMe app access but lacks the required TrackMe capabilities, they get this error screen instead:
Here the roles carry the TrackMe capabilities natively, so the user can access the resources as intended:
Updating RBAC for an existing tenant¶
You can update a tenant’s RBAC policies and ownership at any time — through the UI or the REST API.
Through the Virtual Tenant UI¶
Open the Virtual Tenants interface, double-click the tenant, and open its administration screen:
Update the ownership and/or RBAC policies carefully: TrackMe updates the tenant configuration and re-assigns all of its knowledge objects if needed, updating their permissions accordingly.
Through the REST API¶
The same update is available from the update_tenant_rbac endpoint. The best way to
discover any endpoint’s usage — its parameters, HTTP method, and ready-to-copy curl and
SPL examples — is the built-in TrackMe REST API Reference UI (open it from
API & Tooling → TrackMe REST API Reference), which documents every endpoint:
For instance, to add the siem_users role to the user access of the
siem-quality-control tenant:
| trackme url=/services/trackme/v2/vtenants/admin/update_tenant_rbac mode=post
body="{'tenant_id': 'siem-quality-control', 'tenant_roles_admin': 'emea_siem_admin',
'tenant_roles_power': 'emea_siem_power',
'tenant_roles_user': 'emea_quality_control,siem_users',
'tenant_owner': 'srv-trackme'}"
Restricting a tenant to specific users¶
On top of the role model, a tenant can be restricted to an allowlist of Splunk
usernames. When the allowlist (tenant_allowed_users) is non-empty, only those users —
plus the tenant owner — see the tenant in the Virtual Tenants UI and via trackmeload;
other ordinary users do not, even with a granting role. splunk-system-user bypasses
this filter so scheduled searches and alert actions keep working. The dedicated findings
workspaces also retain the admin / sc_admin administrative bypass: this is not an
isolation boundary against Splunk administrators. It is an extra restriction layered
over RBAC, not a replacement — a listed user still needs a role that grants access.
Clear the list to remove the restriction. Set it from the
vtenants/admin/update_tenant_visibility endpoint:
| trackme url=/services/trackme/v2/vtenants/admin/update_tenant_visibility mode=post
body="{'tenant_id': 'siem-quality-control', 'tenant_allowed_users': 'alice,bob'}"
See also
Roles & access control — the readable overview of the role model.
Creating a tenant — where RBAC and ownership are first set.
Managing tenants — updating a tenant after creation.
REST API reference — the REST API the
update_tenant_rbaccall uses.User Activity Monitoring — User Activity Monitoring tenants.