---
title: "Get All Domain Users"
url: "https://developer.yukisoftware.com/apis/yuki-platform-api-prod-1/versions/1237fe18-1f8f-477a-8f52-b3546dd409bf/operations/getAllDomainUsers"
---

> Full API specification: https://developer.yukisoftware.com/apis/yuki-platform-api-prod-1/versions/1237fe18-1f8f-477a-8f52-b3546dd409bf.md

# Get All Domain Users

`GET` `/domains/{domain-id}/users`

Operation ID: `getAllDomainUsers`

This endpoint allows retrieving all users within a specific domain. Returns a list of all users with their details including name, email, roles, and language preferences. Users attempting to perform this operation need to ensure they possess the necessary permissions. You should have yukiapi:domain:users:read scope to access this endpoint. <!-- authorization:start --> **Authorization** Called with a **Portal User** token - an employee of an accounting portal. The caller must hold at least one of these roles in the portal: `AccountantManagement`, `Accountant`. <!-- authorization:end -->

## Path parameters

- `domain-id` (string, required) - The domain name

## Query parameters

- `offset` (integer, optional) - The number of items to skip before starting to collect the result set
- `limit` (integer, optional) - The numbers of items to return

## Header parameters

- `Authorization` (string, required) - Bearer token for authentication
- `Content-Type` (string, required) - Content type of the request body

## Responses

- `200` - Paged result of domain users
- `400` - Bad Request
- `401` - Unauthorized
- `403` - Forbidden
- `404` - Not Found
- `500` - Internal Server Error

## OpenAPI definition

```yaml
openapi: 3.0.0
info:
  title: Yuki Platform API Prod
  version: 1.0.52
servers:
  - url: https://apirest.yukiworks.com/api/v1
paths:
  /domains/{domain-id}/users:
    get:
      x-environments:
        - development
        - pilot
        - production
      x-portal-visibility:
        - internal
        - trusted
        - prod
      x-required-roles:
        - any-of:
            - AccountantManagement
            - Accountant
          scope: portal
      summary: Get All Domain Users
      description: >-
        This endpoint allows retrieving all users within a specific domain.
        Returns a list of all users with their details including name, email,
        roles, and language preferences. Users attempting to perform this
        operation need to ensure they possess the necessary permissions. You
        should have yukiapi:domain:users:read scope to access this endpoint.


        <!-- authorization:start -->


        **Authorization**


        Called with a **Portal User** token - an employee of an accounting
        portal.


        The caller must hold at least one of these roles in the portal:
        `AccountantManagement`, `Accountant`.


        <!-- authorization:end -->
      operationId: getAllDomainUsers
      tags:
        - Domain User
      parameters:
        - $ref: "#/components/parameters/AuthorizationHeader"
        - $ref: "#/components/parameters/ContentTypeHeader"
        - $ref: "#/components/parameters/DomainIdPath"
        - $ref: "#/components/parameters/OffsetQuery"
        - $ref: "#/components/parameters/LimitQuery"
      security:
        - vismaConnectPortalUser:
            - yukiapi:domain:users:read
      responses:
        "200":
          $ref: "#/components/responses/DomainUsersPagedResultResponse"
        "400":
          $ref: "#/components/responses/BadRequestResponse"
        "401":
          $ref: "#/components/responses/UnauthorizedResponse"
        "403":
          $ref: "#/components/responses/ForbiddenResponse"
        "404":
          $ref: "#/components/responses/NotFoundResponse"
        "500":
          $ref: "#/components/responses/InternalServerErrorResponse"
security:
  - vismaConnectPortalUser:
      - yukiapi:domain:users:read
components:
  parameters:
    AuthorizationHeader:
      name: Authorization
      in: header
      required: true
      description: Bearer token for authentication
      schema:
        type: string
    ContentTypeHeader:
      name: Content-Type
      in: header
      required: true
      description: Content type of the request body
      schema:
        type: string
        default: application/json
    DomainIdPath:
      name: domain-id
      in: path
      required: true
      description: The domain name
      example: 3afb7b54-6144-4561-9a29-1148006f2375
      schema:
        type: string
    OffsetQuery:
      name: offset
      in: query
      required: false
      description: The number of items to skip before starting to collect the result set
      schema:
        type: integer
    LimitQuery:
      name: limit
      in: query
      required: false
      description: The numbers of items to return
      schema:
        type: integer
  responses:
    DomainUsersPagedResultResponse:
      description: Paged result of domain users
      content:
        application/json:
          schema:
            allOf:
              - $ref: "#/components/schemas/PagedResult"
              - type: object
                properties:
                  items:
                    type: array
                    items:
                      $ref: "#/components/schemas/DomainUser"
    BadRequestResponse:
      description: Bad Request
      content:
        application/problem+json:
          schema:
            $ref: "#/components/schemas/BadRequestError"
    UnauthorizedResponse:
      description: Unauthorized
      content:
        application/problem+json:
          schema:
            $ref: "#/components/schemas/UnauthorizedError"
    ForbiddenResponse:
      description: Forbidden
      content:
        application/problem+json:
          schema:
            $ref: "#/components/schemas/ForbiddenError"
    NotFoundResponse:
      description: Not Found
      content:
        application/problem+json:
          schema:
            $ref: "#/components/schemas/NotFoundError"
    InternalServerErrorResponse:
      description: Internal Server Error
      content:
        application/problem+json:
          schema:
            $ref: "#/components/schemas/InternalServerError"
  schemas:
    PagedResult:
      type: object
      properties:
        totalItems:
          type: integer
          description: Total number of items available
          example: 100
        offset:
          type: integer
          description: Current offset in the list
          example: 10
        limit:
          type: integer
          description: Maximum number of items returned
          example: 20
        items:
          type: array
          items:
            type: object
    DomainUser:
      type: object
      properties:
        userId:
          type: string
          description: The unique identifier of the user
        name:
          type: string
          description: Full name of the user
          example: John Doe
        email:
          type: string
          format: email
          description: User email
          example: john.doe@yuki.nl
        roles:
          $ref: "#/components/schemas/DomainRoles"
        language:
          $ref: "#/components/schemas/Language"
      required:
        - userId
        - name
        - email
    BadRequestError:
      allOf:
        - $ref: "#/components/schemas/ProblemDetails"
      example:
        type: https://example.com/errors/bad-request
        title: Bad Request
        status: 400
        detail: The request is invalid or malformed.
        instance: /example/bad-request
    UnauthorizedError:
      allOf:
        - $ref: "#/components/schemas/ProblemDetails"
      example:
        type: https://example.com/errors/unauthorized
        title: Unauthorized
        status: 401
        detail: Authentication is required.
        instance: /example/unauthorized
    ForbiddenError:
      allOf:
        - $ref: "#/components/schemas/ProblemDetails"
      example:
        type: https://example.com/errors/forbidden
        title: Forbidden
        status: 403
        detail: You do not have permission to access this resource.
        instance: /example/forbidden
    NotFoundError:
      allOf:
        - $ref: "#/components/schemas/ProblemDetails"
      example:
        type: https://example.com/errors/not-found
        title: Not Found
        status: 404
        detail: The requested resource could not be found.
        instance: /example/not-found
    InternalServerError:
      allOf:
        - $ref: "#/components/schemas/ProblemDetails"
      example:
        type: https://example.com/errors/internal-server-error
        title: Internal Server Error
        status: 500
        detail: An unexpected error occurred.
        instance: /example/internal-server-error
    DomainRoles:
      type: array
      description: User roles for the domain
      items:
        type: string
        enum:
          - Accountant
          - Backoffice
          - BackofficeController
          - FinAdmin
          - HRM
          - Management
          - Procurement
          - Purchase
          - Sales
          - SecurityManager
          - ReadOnlyUser
    Language:
      type: string
      enum:
        - nl-BE
        - en-US
        - fr-BE
        - nl-NL
      description: |
        The locale for the domain. \
        BE: nl-BE, en-US, fr-BE. \
        NL: en-US, nl-NL
      example: en-US
    ProblemDetails:
      type: object
      properties:
        type:
          type: string
          example: https://dev.yuki.nl/errors/problem
        title:
          type: string
          example: Problem
        status:
          type: integer
          example: 500
        detail:
          type: string
          example: An unexpected error occurred.
        instance:
          type: string
          example: /example/endpoint
  securitySchemes:
    vismaConnectPortalUser:
      type: oauth2
      description: >
        Visma Connect token belonging to a **Portal User** - an employee of an
        accounting portal. The token carries a `portal-id` claim, and the portal
        it identifies must match the portal in the route. Unless an endpoint
        says otherwise, the caller's roles are resolved against the portal.
      flows:
        authorizationCode:
          authorizationUrl: https://connect.identity.stagaws.visma.com/connect/authorize
          tokenUrl: https://connect.identity.stagaws.visma.com/connect/token
          scopes:
            yukiapi:domain:companies:read: Allows reading information of a Company
            yukiapi:domain:companies:update: Allows the update of a Company
            yukiapi:portal:portals:read: Allows reading portal information
            yukiapi:domain:domains:read: Allows reading domains information
            yukiapi:domain:domains:write: Allows modifications of domain information, may
              include create/update
            yukiapi:domain:domains:create: Allows the creation of new domains
            yukiapi:domain:domains:update: Allows updating existing domain information
            yukiapi:domain:domains:delete: Allows the deletion of domain data
            yukiapi:domain:users:read: Allows reading of domain user data
            yukiapi:domain:users:write: Allows the update of domain user data, may include create/update
            yukiapi:domain:users:update: Allows updating a Domain User
            yukiapi:domain:users:delete: Allows the deletion of Domain Users
            yukiapi:portal:portals:write: Allows updating existing portal information
            yukiapi:portal:users:read: Allows reading Portal user data
            yukiapi:portal:users:write: Allows the update of Portal user, may include create/update
            yukiapi:portal:users:update: Allows updating an existing Portal User
            yukiapi:portal:users:delete: Allows the deletion of a Portal User
```
