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

User permissions on the TrackMe search tier

Role

Capability

Tenant operations

trackme_user

trackmeuseroperations

Read the tenant’s monitoring results, subject to the component’s access rules.

trackme_power

trackmepoweroperations

Operate existing monitoring. In HEC, S2S, UF Fleet, Forwarder Collectors, Stream and Edge: triage findings and Finding groups, assign, annotate and use permitted actions.

trackme_admin

trackmeadminoperations

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. nobody and splunk-system-user are 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-user is 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:

Named-owner requirement on the TrackMe tier

Capability

Scope

trackmeuseroperations

TrackMe user operations

trackmepoweroperations

TrackMe power operations

trackmeadminoperations

TrackMe administration operations

schedule_search

Scheduled searches

list_settings

Splunk settings reads

list_storage_passwords

Splunk credential-store reads

admin_all_objects

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.

Local and remote collection identities Local searches use the scheduled execution identity. Remote searches use the destination token user after local account authorization. Additional API connections have independent destination permissions. A local grant does not cross the connection Follow the identity from the scheduled report to the system it reads. LOCAL SEARCH Tenant report Runs on the TrackMe tier Execution identity Named owner or Splunk context Searchable indexers Source index permissions on the local search tier REMOTE SEARCH Tenant report Owner may use remote account Remote account Stores the destination token Remote search tier Search runs as the token user Destination index permissions ADDITIONAL API Component collection Uses its selected API account API credential Separate from telemetry source Endpoint / Leader Splunk or Cribl identity Destination API permissions An interactive fetch may use the caller instead of the scheduled owner. Check both identities when a manual action works but scheduled collection fails.
Which identity must have the permission?

Read

Acting identity

Access to check

Scheduled local search

Named tenant owner, or Splunk’s execution context for nobody

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.

Source data required by each component

Component

Indexes

Reader / condition

UAM

_audit, _introspection, _internal

The route account that searches audit, resource and indexer activity. Inventory accounts on other tiers have separate REST/object requirements.

Splunk HEC

_internal, _introspection

Owner for a local source; token user for a remote source

Splunk S2S

_internal; _metrics when the metrics form is used; _introspection for resource observations

Source reader. Keep _internal available for logs and qualification even when connection telemetry uses _metrics.

Splunk UF Fleet

Telemetry: _internal, plus _metrics / _introspection when used. Deployment Server data: _dsphonehome, _dsclient, _dsappevent

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

_internal, _introspection, _configtracker (Splunk 9.0 or later on the collectors)

Owner for a local source; token user for a remote source

Cribl Stream

The configured Cribl internal-metrics index, for example cribl_metrics

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 admin_all_objects

Administrative access across UAM tenants

trackmeadminoperations + a tenant admin role

UAM workspace, configuration, collection, policies and decisions

trackmepoweroperations + a tenant power role

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

Requirements on the tier being read

Capability / access

Local tier: named owner

Remote tier: token user

search

Required

Required

trackmeadminoperations or admin_all_objects

Required; with TrackMe admin access, the owner also needs a tenant admin role

Required. Without TrackMe installed there, trackmeadminoperations is not defined: admin_all_objects is the available alternative.

list_all_users and list_all_roles

Not needed for the local identity catalogs: TrackMe’s authorized identity reader performs those reads

Required to enumerate all users and roles. edit_user / edit_roles also satisfy the corresponding checks, but are broader than the read capabilities.

list_search_head_clustering

Required for a search head cluster

Required for a search head cluster

Source index access

_audit, _introspection, _internal when this is the route account

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.

Keep the two cluster identities separate

Read

Account and capabilities

What it adds

Search head’s cluster view

Local owner or remote source token user: search, rest_properties_get and list_indexer_cluster

cluster/searchhead/generation and peer cluster/peer/info reads: cluster membership and the view available through the search tier

Optional manager view

Cluster manager account’s token user, on the manager: search, rest_properties_get, list_indexer_cluster

Manager configuration, maintenance/rolling-restart state and peers from cluster/config/config, cluster/manager/info and cluster/manager/peers

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.

UF Fleet telemetry, Deployment Server event source, and Deployment Server API accounts UF Fleet has a main telemetry source, a separate Deployment Server event source and optional Deployment Server API accounts. The API user needs search, rest_properties_get, list_deployment_server and the three DS indexes on the Deployment Server itself. UF Fleet has three independent access paths Each selected remote account must be usable by the tenant owner. 01 TELEMETRY SOURCE Search head Local or remote search tier GRANT TO THIS READER search _internal _metrics / _introspection when used PROVIDES Receivers and agent telemetry 02 DS EVENT SOURCE Where DS events live Local or remote search tier GRANT TO THIS READER search _dsphonehome _dsclient _dsappevent PROVIDES Phonehomes and deployments 03 DS API · OPTIONAL Deployment Server Token user on the DS itself GRANT TO THIS READER search + rest_properties_get list_deployment_server AND the same three DS indexes on that server PROVIDES Current server-class membership The API also searches the DS indexes as its caller. A valid token + list_deployment_server can still return no clients without index access.
UF Fleet account map

Selection

Required access

Purpose

Source

Local execution identity or remote source token: search and forwarding telemetry indexes (_internal; _metrics / _introspection when used)

Receivers’ connection records, agent logs and resource observations

Deployment Server source

Local execution identity or its own remote token: search and _dsphonehome, _dsclient, _dsappevent (or configured replacements)

Phonehomes, client properties and app-deployment events

Deployment Server API accounts — optional

On each Deployment Server: search, rest_properties_get, list_deployment_server and access to the three DS indexes

Read /services/deployment/server/clients for current server-class membership

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.

Splunk Forwarder Collectors account map

Selection

Required access

Purpose

Source

Local execution identity or remote source token: search and _internal, _introspection, _configtracker

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: search, rest_properties_get and list_inputs

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:

  1. Cribl internal metrics in a Splunk metric index searchable from the local TrackMe tier. The scheduled execution identity needs search and access to that index. The index may be on distributed indexers, but the current Stream metric source is local; a TrackMe remote metric-source account is not supported.

  2. 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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

Symptoms identify different permission layers

Symptom

Check first

Tenant missing or an action forbidden

TrackMe capability, tenant role lists, inherited roles and the username allowlist

insufficient_tenant_owner_capabilities

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

remote_account_refused / account_access_denied

Local permission to use the account, distinct from destination token permissions

UAM catalog contains only the reader

Remote list_all_users / list_all_roles and effective identity visibility

cluster_read_refused

list_indexer_cluster on the source reader, not only on the manager account

cluster_manager_unreadable

The separate manager account, its destination, connectivity and three manager reads

DS API returns no clients

The API user’s _ds* index access, recent phonehomes and the DS cluster member

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.

Native System settings showing Knowledge objects and RBAC defaults for new tenants

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:

screen1.png

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 role secops_emea

  • secops-amer — Americas team, Splunk role secops_amer

  • secops-uk — UK team, Splunk role secops_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:

img-006060@2x.png

If a user is granted TrackMe app access but lacks the required TrackMe capabilities, they get this error screen instead:

img-006062@2x.png

Here the roles carry the TrackMe capabilities natively, so the user can access the resources as intended:

rbac-example07.png

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:

img-006066@2x.png

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:

The TrackMe REST API Reference UI showing the update_tenant_rbac endpoint — its description, HTTP method, curl and SPL examples, and parameter documentation

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