diff --git a/ControlAcceso.Tests/Data/PermissionsDbContextTests.cs b/ControlAcceso.Tests/Data/PermissionsDbContextTests.cs
index 48eaa30..d636f68 100644
--- a/ControlAcceso.Tests/Data/PermissionsDbContextTests.cs
+++ b/ControlAcceso.Tests/Data/PermissionsDbContextTests.cs
@@ -18,42 +18,64 @@ public PermissionsDbContextTests()
         }
 
         [Fact]
-        public void GetGroupedPermissions_ReturnsDictionaryOfPermissions()
+        public void GetGroupedPermissions_ShouldReturnPermissions_WhenDataExists()
         {
             // Arrange
+            var roleId = 1;
+            var userId = 2;
+            
             var mockData = new List<Dictionary<string, object>>
             {
                 new Dictionary<string, object>
                 {
-                    { "entity", "users" }, 
-                    { "permissions", new List<string> { "Read", "Write" } }
+                    { "entity", "Users" },
+                    { "permissions", new string[] { "Read", "Write" } }
                 },
                 new Dictionary<string, object>
                 {
-                    { "entity", "package" }, 
-                    { "permissions", new List<string> { "Delete" } }
+                    { "entity", "Orders" },
+                    { "permissions", new string[] { "Execute" } }
                 }
             };
 
-            _mockDbService.Setup(x => x.ExecuteReader(It.IsAny<string>(), It.IsAny<Dictionary<string, dynamic>>() ))
-                        .Returns(mockData);
+            _mockDbService.Setup(db => db.ExecuteReader(
+                It.IsAny<string>(),
+                It.IsAny<Dictionary<string, dynamic>>()
+            )).Returns(mockData);
 
             // Act
-            var result = _dbContext.GetGroupedPermissions(1, 1);
+            var result = _dbContext.GetGroupedPermissions(roleId, userId);
 
             // Assert
             Assert.NotNull(result);
             Assert.Equal(2, result.Count);
 
-            Assert.True(result.ContainsKey("users"));
-            Assert.Contains("Read", (List<string>)result["users"]);
-            Assert.Contains("Write", (List<string>)result["users"]);
+            Assert.True(result.ContainsKey("Users"));
+            Assert.Equal(new List<string> { "Read", "Write" }, result["Users"]);
 
-            Assert.True(result.ContainsKey("package"));
-            Assert.Contains("Delete", (List<string>)result["package"]);
+            Assert.True(result.ContainsKey("Orders"));
+            Assert.Equal(new List<string> { "Execute" }, result["Orders"]);
         }
 
+        [Fact]
+        public void GetGroupedPermissions_ShouldReturnEmptyDictionary_WhenNoDataExists()
+        {
+            // Arrange
+            var roleId = 3;
+            var userId = 4;
+
+            _mockDbService.Setup(db => db.ExecuteReader(
+                It.IsAny<string>(),
+                It.IsAny<Dictionary<string, dynamic>>()
+            )).Returns(new List<Dictionary<string, object>>());
 
+            // Act
+            var result = _dbContext.GetGroupedPermissions(roleId, userId);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Empty(result);
+        }
 
         [Fact]
         public void GetGroupedPermissions_ReturnsEmptyDictionary_WhenNoPermissions()
@@ -82,5 +104,59 @@ public void GetGroupedPermissions_HandlesException_Gracefully()
 
             Assert.Equal("SqlState: Database connection failed", exception.Message);
         }
+
+        [Fact]
+        public void GetRolePermissions_ShouldReturnGroupedPermissions_WhenDataExists()
+        {
+            // Arrange
+            var roleId = 1;
+            var mockData = new List<Dictionary<string, object>>
+            {
+                new Dictionary<string, object>
+                {
+                    { "entity", "Users" },
+                    { "permissions", new string[] { "Read", "Write" } }
+                },
+                new Dictionary<string, object>
+                {
+                    { "entity", "Orders" },
+                    { "permissions", new string[] { "Execute" } }
+                }
+            };
+
+            _mockDbService.Setup(db => db.ExecuteReader(
+                It.IsAny<string>(),
+                It.IsAny<Dictionary<string, dynamic>>()
+            )).Returns(mockData);
+
+            // Act
+            var result = _dbContext.GetRolePermissions(roleId);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(2, result.Count);
+            Assert.True(result.ContainsKey("Users"));
+            Assert.Equal(new List<string> { "Read", "Write" }, result["Users"]);
+            Assert.True(result.ContainsKey("Orders"));
+            Assert.Equal(new List<string> { "Execute" }, result["Orders"]);
+        }
+
+        [Fact]
+        public void GetRolePermissions_ShouldReturnEmptyDictionary_WhenNoDataExists()
+        {
+            // Arrange
+            var roleId = 2;
+            _mockDbService.Setup(db => db.ExecuteReader(
+                It.IsAny<string>(),
+                It.IsAny<Dictionary<string, dynamic>>()
+            )).Returns(new List<Dictionary<string, object>>());
+
+            // Act
+            var result = _dbContext.GetRolePermissions(roleId);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Empty(result);
+        }
     }
 }
diff --git a/ControlAcceso/Data/Model/PermissionModel.cs b/ControlAcceso/Data/Model/PermissionModel.cs
index 0a1589f..d17bfc9 100644
--- a/ControlAcceso/Data/Model/PermissionModel.cs
+++ b/ControlAcceso/Data/Model/PermissionModel.cs
@@ -1,6 +1,8 @@
-namespace ControlAcceso.Data.Model;
-public class GroupedPermission
+namespace ControlAcceso.Data.Model
 {
-    public string Entity { get; set; } = string.Empty;
-    public List<string> Permissions { get; set; } = new();
+    public class PermissionModel
+    {
+        public string Entity { get; set; } = string.Empty;
+        public List<string> Permissions { get; set; } = new();
+    }
 }
diff --git a/ControlAcceso/Data/Permissions/IPermissionsDbContext.cs b/ControlAcceso/Data/Permissions/IPermissionsDbContext.cs
index 1d22f36..260ca95 100644
--- a/ControlAcceso/Data/Permissions/IPermissionsDbContext.cs
+++ b/ControlAcceso/Data/Permissions/IPermissionsDbContext.cs
@@ -2,5 +2,6 @@
 
 namespace ControlAcceso.Data.Permissions;
 public interface IPermissionsDbContext{
+    public Dictionary<string,List<string>> GetRolePermissions(int roleId);
     public Dictionary<string,List<string>> GetGroupedPermissions(int roleId, int userId);
 }
\ No newline at end of file
diff --git a/ControlAcceso/Data/Permissions/PermissionsDbContext.cs b/ControlAcceso/Data/Permissions/PermissionsDbContext.cs
index 00ea2b2..98d0855 100644
--- a/ControlAcceso/Data/Permissions/PermissionsDbContext.cs
+++ b/ControlAcceso/Data/Permissions/PermissionsDbContext.cs
@@ -13,6 +13,27 @@ public PermissionsDbContext(IDbService dbService)
             DbService = dbService;
         }
 
+       public Dictionary<string, List<string>> GetRolePermissions(int roleId)
+        {
+            var query = @"
+                SELECT entity, ARRAY_AGG(DISTINCT permission) AS permissions
+                FROM role_permissions
+                WHERE role_id = @RoleId
+                GROUP BY entity";
+
+            var parameters = new Dictionary<string, dynamic> { { "@RoleId", roleId } };
+            var rows = DbService.ExecuteReader(query, parameters);
+
+            var groupedPermissions = rows.Select(row => new PermissionModel
+            {
+                Entity = row["entity"]?.ToString()!,
+                Permissions = (((string[])row["permissions"]) ?? Array.Empty<string>())
+                                .ToList()
+            }).ToList();
+
+            return groupedPermissions.ToDictionary(gp => gp.Entity, gp => gp.Permissions);
+        }
+
         public Dictionary<string,List<string>> GetGroupedPermissions(int roleId, int userId)
         {
             var query = @"
@@ -36,11 +57,10 @@ FROM user_permissions
 
             var rows = DbService.ExecuteReader(query, parameters);
 
-            var groupedPermissions = rows.Select(row => new GroupedPermission
+            var groupedPermissions = rows.Select(row => new PermissionModel
             {
                 Entity = row["entity"]?.ToString()!,
-                Permissions = ((List<string>)row["permissions"]!)
-                                .Select(permission => permission.ToString()!)
+                Permissions = (((string[])row["permissions"]) ?? Array.Empty<string>())
                                 .ToList()
             }).ToList();
 
diff --git a/ControlAcceso/Endpoints/Roles/Endpoint.cs b/ControlAcceso/Endpoints/Roles/Endpoint.cs
index e655d26..9a296f8 100644
--- a/ControlAcceso/Endpoints/Roles/Endpoint.cs
+++ b/ControlAcceso/Endpoints/Roles/Endpoint.cs
@@ -72,5 +72,12 @@ public IActionResult GetPermissions(int idRole, int idUser)
 
                 return Ok(new PermissionsResponse { Message = "OK", Permissions = groupedPermissions });         
         }
+        [HttpGet("{idRole}/nodes")]
+        public IActionResult GetRolePermissions(int idRole)
+        {
+            var permissions = _permissions?.GetRolePermissions(idRole);
+            return Ok(new PermissionsResponse {Message = "OK", Permissions=permissions});
+            
+        }
     }
 }
\ No newline at end of file
diff --git a/init.sql b/init.sql
index 6e6e89e..eccc0c0 100644
--- a/init.sql
+++ b/init.sql
@@ -72,11 +72,3 @@ create table role_permissions (
     entity VARCHAR NOT NULL,
     permission VARCHAR NOT NULL
 );
-create table user_permissions (
-    id SERIAL PRIMARY KEY,
-    user_id INTEGER NOT NULL
-        CONSTRAINT fk_user_permission_user 
-        REFERENCES users(id) ON DELETE CASCADE,
-    entity VARCHAR NOT NULL,
-    permission VARCHAR NOT NULL
-);
\ No newline at end of file