> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowpayroll.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# List the payslips of a pay run still being calculated

> Needs permission pay-run:read.

The payslips of a pay run that are queued for calculation and have not finished yet, oldest
first, with how many there are and when the oldest was queued. A payslip is queued whenever
something it depends on changes (a pay line, the employee, the pay run itself) and leaves
this list once its calculation has been written, so a pending count of 0 means every
payslip of the run is up to date: ask before reading figures you have just changed, and
before locking. A calculation queued long ago that is still listed did not complete and will
not leave the list on its own.



## OpenAPI

````yaml /api-reference/specs/pay-api.yaml get /payroll/{payrollConfigId}/{year}/{period}/processing
openapi: 3.0.3
info:
  title: FlowPayroll API
  description: >-
    API for payroll management, including payroll upload, lock, HMRC submission,
    employee management
  version: 0.1.0
servers:
  - url: https://api.sandbox.flowpayroll.ai/v1
security:
  - XAuthToken: []
    XOrgId: []
tags:
  - name: Employees
    description: >-
      Create, retrieve, update, and delete employee records, and look them up by
      NI number or payroll ID.
  - name: Starters & leavers
    description: Set and clear starter and leaver details, individually or in bulk.
  - name: Tax codes
    description: >-
      Manage employee tax codes and query the effective tax code and NI category
      on a given date.
  - name: NI & identifiers
    description: Manage NI categories, National Insurance numbers, and payroll IDs.
  - name: Student loans
    description: Start and end student and postgraduate loans.
  - name: Payroll setup
    description: Assign an employee's payroll config and set opening balances.
  - name: Salary
    description: >-
      The employee's effective-dated annual salary history: read it, add or
      correct a version from a date, and remove one. The Salary API pro-rates
      this history onto each pay run.
  - name: Payroll
  - name: Payroll lines
  - name: PayrollConfig
  - name: Pay Elements
  - name: Calculator
  - name: Payslip
  - name: RTI
  - name: YearEnd
  - name: Organisation
paths:
  /payroll/{payrollConfigId}/{year}/{period}/processing:
    get:
      tags:
        - Payroll
      summary: List the payslips of a pay run still being calculated
      description: >-
        Needs permission pay-run:read.


        The payslips of a pay run that are queued for calculation and have not
        finished yet, oldest

        first, with how many there are and when the oldest was queued. A payslip
        is queued whenever

        something it depends on changes (a pay line, the employee, the pay run
        itself) and leaves

        this list once its calculation has been written, so a pending count of 0
        means every

        payslip of the run is up to date: ask before reading figures you have
        just changed, and

        before locking. A calculation queued long ago that is still listed did
        not complete and will

        not leave the list on its own.
      operationId: GetPayrollRunProcessing
      parameters:
        - name: payrollConfigId
          in: path
          required: true
          schema:
            type: string
          description: ID of the payroll configuration
          example: 01JNR9P81W74HYCN35X1EEFDZE
        - name: year
          in: path
          required: true
          schema:
            type: integer
            format: int32
          description: Year of the pay run
          example: 2026
        - name: period
          in: path
          required: true
          schema:
            type: integer
            format: int32
          description: Pay period number within the year
          example: 7
        - $ref: '#/components/parameters/Request-Id'
      responses:
        '200':
          description: The payslips still being calculated were retrieved successfully
          content:
            application/json:
              schema:
                type: object
                allOf:
                  - $ref: '#/components/schemas/ResponseBody'
                  - properties:
                      content:
                        type: object
                        properties:
                          data:
                            $ref: '#/components/schemas/PayrollRunProcessingDto'
        '400':
          description: The request is invalid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
        '403':
          description: Forbidden
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
        '404':
          description: The payroll config or the pay run was not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
        '500':
          description: An error occurred
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
        '503':
          description: Service Unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponseBody'
components:
  parameters:
    Request-Id:
      name: Request-Id
      in: header
      required: false
      description: >-
        Optional. Your id for this request: it is carried into every log line
        about it, so quote it when you contact support.
      schema:
        type: string
  schemas:
    ResponseBody:
      type: object
      required:
        - message
      properties:
        message:
          $ref: '#/components/schemas/MessageWithTokenResponse'
          description: >-
            A readable message about the outcome and a stable token a client can
            branch on.
        content:
          type: object
          required:
            - metadata
          properties:
            data:
              description: >-
                The resource or list the request asked for; left out when there
                is none.
            metadata:
              type: object
              required:
                - dateFormat
                - dateTimeFormat
              properties:
                dateFormat:
                  type: string
                  description: The format of the dates in this response, yyyy-MM-dd.
                dateTimeFormat:
                  type: string
                  description: >-
                    The format of the timestamps in this response,
                    yyyy-MM-ddTHH:mm:ss.fffZ in UTC.
                paginationToken:
                  type: string
                  nullable: true
                  description: >-
                    Send this value back as the paginationToken query parameter
                    to get the next page; absent when there are no more pages.
              description: >-
                The date formats the response uses and, on a paged list, the
                token for the next page.
          description: >-
            The data the request returns with its metadata; left out on a
            response that carries no data, such as most errors.
        validationIssues:
          type: array
          items:
            $ref: '#/components/schemas/ValidationIssue'
          nullable: true
          description: >-
            Each field the request was refused for and why; left out when the
            request was not refused for its fields.
    PayrollRunProcessingDto:
      type: object
      description: >-
        The payslips of a pay run that are queued for calculation and have not
        finished yet. A payslip

        is queued whenever something it depends on changes and leaves once its
        calculation has been

        written, so a run whose pending count is 0 has every payslip up to date.
      required:
        - pendingCount
        - payslips
      properties:
        pendingCount:
          type: integer
          format: int32
          description: >-
            How many calculations are still outstanding; 0 when every payslip of
            the run is up to date
          example: 2
        oldestQueuedAt:
          type: string
          nullable: true
          description: >-
            When the oldest outstanding calculation was queued, UTC; null when
            none is outstanding. A calculation queued long ago that is still
            outstanding did not complete and will not finish on its own.
          example: '2026-11-06T10:15:02.114Z'
        payslips:
          type: array
          items:
            $ref: '#/components/schemas/PayslipProcessingDto'
          description: >-
            The outstanding calculations, oldest first. An employee appears once
            for each calculation still outstanding.
    MessageWithTokenResponse:
      type: object
      required:
        - text
        - token
      properties:
        text:
          type: string
          description: The message in English, ready to show to a user.
        token:
          type: string
          description: >-
            A stable snake_case key for the message, so a client can show its
            own wording or a translation instead of text.
        tokenArguments:
          type: array
          items:
            $ref: '#/components/schemas/ValidationIssueArgument'
          nullable: true
          description: >-
            Values to fill into the client's own wording for token, such as the
            request id; absent when the message has none.
    ValidationIssue:
      type: object
      description: >-
        Field validation item. `reasonToken` is a stable snake_case key for i18n
        or custom client messages; `reason` is the default English text from the
        API.
      required:
        - field
        - reason
        - reasonToken
      properties:
        field:
          type: string
          description: Dot-path of the field (e.g. name.firstName, address.line1).
        reason:
          type: string
          description: Default human-readable message.
        reasonToken:
          type: string
          description: Machine-readable error identifier (snake_case).
        reasonTokenArguments:
          type: array
          items:
            $ref: '#/components/schemas/ValidationIssueArgument'
          nullable: true
          description: >-
            Values to fill into the client's own wording for reasonToken; absent
            when the reason has none.
    PayslipProcessingDto:
      type: object
      description: >-
        A payslip of a pay run that is queued for calculation and has not
        finished yet. An employee

        appears once for each calculation still outstanding, so the same
        employee can appear more

        than once when their payslip was queued again before the first
        calculation finished.
      required:
        - employeeId
        - processId
        - reason
        - queuedAt
      properties:
        employeeId:
          type: string
          description: The employee whose payslip is being calculated
        processId:
          type: string
          description: Identifies this calculation
        reason:
          type: string
          enum:
            - Other
            - PayLineChanged
            - EmployeeChanged
            - AddedToPayRun
            - PreviousPayslipChanged
            - PayRunUnlocked
          description: >-
            Why the payslip was queued: PayLineChanged (a pay line was added,
            changed or removed), EmployeeChanged (the employee's details
            changed, or a recalculation was requested), AddedToPayRun (the
            employee joined the pay run: it was opened with them, they were
            onboarded or changed so they belong in it, or a leaver was added to
            it to be paid), PreviousPayslipChanged (the employee's payslip for
            an earlier period changed or was finalised, so this one starts from
            new year-to-date figures), PayRunUnlocked (the pay run was
            unlocked), or Other. More values may be added: read any value you do
            not recognise as Other.
        queuedAt:
          type: string
          description: When the calculation was queued, UTC
        correlationId:
          type: string
          nullable: true
          description: >-
            The id of the request that queued the calculation, when there was
            one
    ValidationIssueArgument:
      type: object
      required:
        - name
        - value
      properties:
        name:
          type: string
          description: The name of the value, as a client's wording refers to it.
        value:
          description: The value itself, as a string, number or other JSON value.
  securitySchemes:
    XAuthToken:
      type: apiKey
      in: header
      name: X-Auth-Token
      description: Access token obtained from OAuth2 client credentials flow
    XOrgId:
      type: apiKey
      in: header
      name: X-Org-Id
      description: >-
        Organisation to scope the request to. Required when the principal can
        access more than one organisation; optional for single-organisation
        principals (the authorizer resolves it automatically).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.