> For the complete documentation index, see llms.txt.
Skip to main content

Check out Port for yourself ➜ 

Govern data access

Port provides granular control to ensure that every user only sees the parts of the catalog that are relevant to them.

Upcoming change: relation and mirror property permissions (February 28, 2027)

Starting February 28, 2027, read access to relations and mirror properties will be determined by the target blueprint's permissions.
Users who can't read the target blueprint's entities will no longer see the related values.
To check whether your organization is affected and how to prepare, see relation and mirror property permissions.

Port's catalog RBAC capabilities are enabled by utilizing permissions controls.

Page permissions

In order to manage who can view certain pages in Port, check out page permissions.

Common usage​

The catalog RBAC mechanism allows admins to finely control which users have access to specific information in the software catalog, for example:

  • Allow a user to edit a single specific property on an entity.
  • Create a fully read-only view for a developer.
  • Allow users to create, edit, and delete only entities owned by their team.
  • Restrict entity visibility to users whose team matches the entity's owner team.
  • Allow only users with the on-call property set to true to edit entities owned by their team.

Set access controls for catalog data​

The default permissions assigned to every blueprint upon creation specify that users with the admin role and users with the specific blueprint moderator role can edit the blueprint itself and manage its permissions.
See RBAC permissions for more information about the different roles.

The permissions described below control access to blueprint entities and their properties, not to the blueprint structure or permissions configuration itself. You can control who reads, creates, updates, or deletes entities, and who can view or edit specific properties within those entities.

It is possible to assign global permissions controls for a blueprint's entities and properties, using the following steps:

  1. Go to the Context lake page of your portal.

  2. Select your desired blueprint, click on the ... button in the top-right corner, and select Permissions:

  3. A dialog will open with two tabs:

    • Entities tab - set entity-level permissions (who can read, create, update, or delete entities)
    • Properties tab - set property-level permissions (who can update or view specific properties)

You can also manage these permissions via the Port API, Terraform, or Pulumi. Terraform and Pulumi support roles, users, teams, team ownership (owned_by_team), and update property/relation scopes. Advanced dynamic policies (policy) are not supported in those providers yet - configure them in the UI or via the API.

The Entities tab controls who can read, create, update, or delete entities. Configure entity-level access below by role, user/team, entity ownership, or dynamic policy.

This section allows you to assign permissions for a role (Member, Admin or Moderator).

Click on the dropdown in the desired role row and select the permissions that will be assigned to it.

Blueprint permission dropdown Read option

Edit via JSON (click to expand)

To edit permissions via JSON, click on the Edit JSON button in the top-right corner of the dialog.

To give permissions to a role, add it to the roles array in the permission scope you desire (read, register, unregister, or update):

{
"entities": {
"read": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
},
"register": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
},
"unregister": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
},
"update": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
},
"updateProperties": {
"$identifier": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
}
// ...other properties
},
"updateRelations": {
"service": {
"roles": ["myBlueprint-moderator", "Admin", "Member"],
// ...other permissions
}
// ...other relations
}
}
}
Affected components

Setting read permissions on entities takes effect at the API level, meaning that any component in Port that fetches entities will be affected by these permissions.
For example, a table widget that displays entities will only show entities that the user has read permissions for.

Relation and mirror property permissions​

Today, a user who can read an entity also sees all of its relations and mirror properties, even when they can't read the related entities directly.
Starting February 28, 2027, Port will apply the target blueprint's read permissions to relations and mirror properties.
After this change, the source blueprint's permissions no longer decide what a user sees on relations and mirror properties.

How access is determined​

For every relation and mirror property, Port checks the user's read access on the target blueprint:

Read access on the target blueprintWhat the user sees
Full read (by role, user, or team)The relation or mirror property, with no change.
Entity owners only (ownedByTeam)Only related entities owned by one of the user's teams.
Dynamic policy (policy)Only related entities that match the target blueprint's policy.
No read accessThe relation or mirror property is hidden and returns null.

A mirror property is also hidden when the mirrored property itself is restricted by read properties on the target blueprint and the user isn't allowed to read it.

These rules apply everywhere entities are read, including the UI, the entity search API, dashboards, and the permission simulator.
Requests made by integrations and other machine users are not affected.

Who is affected​

Your organization is affected if users can read a blueprint but can't read a blueprint that it relates to or mirrors from.
A common example is a service blueprint that all Member users can read, with a relation to a team or incident blueprint that only some users can read.
If every role that reads a source blueprint can also read its target blueprints, you don't need to do anything.

Complete these steps before February 28, 2027

To prepare for the change, review and update your blueprint permissions before February 28, 2027. Otherwise, users who can't read a target blueprint will stop seeing its related values when the new behavior takes effect.

Review the permissions of each blueprint that other blueprints relate to or mirror from:

  1. Go to the data model page and open a blueprint that has relations or mirror properties.
  2. For each relation and mirror property, note the target blueprint.
  3. Open the target blueprint's Permissions and check who has read access on the Entities tab.
  4. Choose the behavior you want:
    • Show related values to the same users (current behavior) - grant read access on the target blueprint to the same roles, users, or teams that read the source blueprint (for example, add Member to entities.read.roles).
    • Adopt the stricter behavior - leave the target permissions as they are. Users will only see related values that they are allowed to read.
  5. If a mirror property points to a property restricted with readProperties on the target blueprint, grant read on that property to users who should keep seeing the mirrored value.

For example, the following change on the target blueprint keeps relations and mirror properties visible to all Member users:

{
"entities": {
"read": {
"roles": ["myTargetBlueprint-moderator", "Admin", "Member"]
// ...other permissions
}
}
}
Early access

To enable the new behavior for your organization before February 28, 2027, contact Port's support team.

Permission simulator​

The permission simulator allows you to test and validate blueprint permissions before saving them.
You can simulate read, register (create), update, and unregister (delete) access for any user in your organization and quickly understand why access is granted or denied. It's available from Port AI, the UI, or the API, not only from the browser.

Use the simulator​

Ask Port AI, or your coding agent over the Port MCP server, to run the check in plain language. For example:

"Why can Alex Chen update the checkout-service entity on the Service blueprint?"

Port AI runs the simulator and reports the exact rule that grants access, for example that Alex is on the team that owns checkout-service.

"Which services can anyone on the security-team currently update?"

Port AI returns every entity accessible under that rule, useful for checking a policy's blast radius before you widen it to more teams.

How permissions are evaluated​

The simulator evaluates five checks. Access is granted if any one of the following checks passes:

  1. Role check - verifies whether the user's role is included in the operation's allowed roles.
  2. Owned by team - when ownedByTeam is enabled, verifies whether the user belongs to at least one team in the entity's $team.
  3. Team list - verifies whether the user belongs to any team listed in the operation's teams.
  4. User list - verifies whether the user is explicitly listed in the operation's users.
  5. Policy - verifies whether the entity matches the configured policy query.

When access is granted, the simulator indicates the granting path, for example: "Has role Admin which allows this operation".
For policy-based access, the evaluated query is also displayed.

Software catalog RBAC examples​

Refer to the examples page for practical examples of Port's RBAC.

FAQ​