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

# What a partner's customers store

> Says how many files, and how many bytes, your account keeps, in total and for each of your managed users, and
how much of it is in Widgetic's storage and how much in your own storage destination
(`setPartnerStorageDestination`). Use it to see which customers store the most, or to charge them for it.

A file is counted for a managed user when it was filed under that user: by naming `managed_user_id` or
`managed_user_external_id` when you upload it (`uploadFile`, or the metadata of a resumable upload), or
because it was uploaded through that user's editor session, which files everything under its user. The files
that are not filed under anyone (your own, and the ones uploaded without naming a managed user) are the row
whose `managedUserId` is null. Deleted files are not counted. To list the files of one managed user, use the
`managed_user_id` filter of `listUploads`.

The answer is counted when you ask, so it is always current. The groups are ordered by size, the heaviest
first, and `page.hasMore` says whether more follow.

The caller must be the person who administers the partner (an API key of that account works, with the
`partner:read` scope), or a Widgetic administrator.




## OpenAPI

````yaml /openapi/widgetic-api-public.json get /partners/{partnerId}/storage/usage
openapi: 3.0.0
info:
  title: Widgetic API Gateway
  version: 1.0.0
  description: API documentation for the Widgetic API Gateway
  license:
    name: Widgetic Integration License
    url: https://docs.widgetic.com/resources/license
servers:
  - url: https://api.widgetic.com/v1
    description: Production server
    variables:
      env:
        default: production
        description: Environment
      apiUrl:
        default: https://api.widgetic.com
        description: API URL
      apiVersion:
        default: /v1
        description: API Version path prefix
security: []
tags: []
paths:
  /partners/{partnerId}/storage/usage:
    get:
      tags:
        - Partners
      summary: What a partner's customers store
      description: >
        Says how many files, and how many bytes, your account keeps, in total
        and for each of your managed users, and

        how much of it is in Widgetic's storage and how much in your own storage
        destination

        (`setPartnerStorageDestination`). Use it to see which customers store
        the most, or to charge them for it.


        A file is counted for a managed user when it was filed under that user:
        by naming `managed_user_id` or

        `managed_user_external_id` when you upload it (`uploadFile`, or the
        metadata of a resumable upload), or

        because it was uploaded through that user's editor session, which files
        everything under its user. The files

        that are not filed under anyone (your own, and the ones uploaded without
        naming a managed user) are the row

        whose `managedUserId` is null. Deleted files are not counted. To list
        the files of one managed user, use the

        `managed_user_id` filter of `listUploads`.


        The answer is counted when you ask, so it is always current. The groups
        are ordered by size, the heaviest

        first, and `page.hasMore` says whether more follow.


        The caller must be the person who administers the partner (an API key of
        that account works, with the

        `partner:read` scope), or a Widgetic administrator.
      operationId: getPartnerStorageUsage
      parameters:
        - in: path
          name: partnerId
          required: true
          schema:
            type: string
            format: uuid
          description: The partner whose storage to report on
        - in: query
          name: limit
          schema:
            type: integer
            minimum: 1
            maximum: 100
            default: 50
          description: How many managed users to list at most
        - in: query
          name: offset
          schema:
            type: integer
            minimum: 0
            maximum: 100000
            default: 0
          description: How many managed users to skip
      responses:
        '200':
          description: What the partner's customers store
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PartnerStorageUsageResponse'
        '400':
          description: A query value is not valid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: The API key is missing or invalid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: The caller does not administer this partner
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: There is no such partner (reported to administrators only)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '409':
          description: >-
            The partner has no administrator account
            (PARTNER_HAS_NO_ADMINISTRATOR)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Too many report requests. Wait a minute.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
      x-code-samples:
        - lang: TypeScript
          label: TypeScript SDK
          source: >
            import { Configuration, PartnersApi } from '@widgetic/api-sdk-ts';


            const partnersApi = new PartnersApi(new Configuration({ apiKey:
            'YOUR_API_KEY' }));


            // What each customer stores, the heaviest first:

            const { data: usage } = await partnersApi.getPartnerStorageUsage({
            partnerId });


            console.log(usage.totals.totalBytes);

            for (const customer of usage.managedUsers) {
              console.log(customer.externalId, customer.totalBytes);
            }
components:
  schemas:
    PartnerStorageUsageResponse:
      type: object
      required:
        - success
        - data
      properties:
        success:
          type: boolean
          description: Always `true` on a success.
          example: true
        data:
          $ref: '#/components/schemas/PartnerStorageUsage'
        meta:
          $ref: '#/components/schemas/ResponseMeta'
    ErrorResponse:
      type: object
      required:
        - success
        - message
        - error
      additionalProperties: true
      properties:
        success:
          type: boolean
          description: Always `false` on a failure.
          example: false
        message:
          type: string
          description: The same text as `error.message`, for a caller that reads one line.
        error:
          $ref: '#/components/schemas/ErrorDetail'
    PartnerStorageUsage:
      type: object
      description: >
        What a partner's customers store. `totals` is every file kept for the
        partner's account; `managedUsers` splits it by the managed user each
        file is filed under, the heaviest first.
      required:
        - partnerId
        - totals
        - managedUsers
        - page
      properties:
        partnerId:
          type: string
          format: uuid
        totals:
          $ref: '#/components/schemas/PartnerStorageUsageTotals'
        managedUsers:
          type: array
          items:
            $ref: '#/components/schemas/PartnerStorageUsageOfManagedUser'
        page:
          $ref: '#/components/schemas/PartnerReportPage'
      example:
        partnerId: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        totals: null
        managedUsers:
          - Example PartnerStorageUsageOfManagedUser
        page: null
    ResponseMeta:
      type: object
      description: >-
        Extra information about the answer: where a page sits in a list, the
        cursor of the next page, or warnings about a call that succeeded with a
        caveat.
      additionalProperties: true
      properties:
        page:
          type: integer
          description: The page that was read, counting from 1.
          example: 1
        size:
          type: integer
          description: How many items one page holds.
          example: 20
        total:
          type: integer
          description: How many items the whole list has.
          example: 135
        limit:
          type: integer
          description: The same as `size`.
          example: 20
        offset:
          type: integer
          description: How many items come before this page.
          example: 0
        hasNextPage:
          type: boolean
          example: true
        hasPreviousPage:
          type: boolean
          example: false
        nextCursor:
          type: string
          nullable: true
          description: >-
            Pass this as `cursor` to read the next page of a list that is read
            by cursor. `null` on the last page.
        warnings:
          type: array
          items:
            type: string
          description: >-
            Things the call did not do, though it succeeded (for example a table
            that could not be created just now).
    ErrorDetail:
      type: object
      required:
        - code
        - message
        - timestamp
      properties:
        code:
          type: string
          description: Machine-readable error code.
          example: RESOURCE_NOT_FOUND
        message:
          type: string
          description: Human-readable explanation.
          example: Composition not found
        param:
          type: string
          description: The field that caused the error, when one did.
          example: name
        docUrl:
          type: string
          description: Where this error is explained.
        suggestedAction:
          type: string
          description: What to do about it.
        retryAfter:
          type: integer
          description: >-
            Seconds to wait before trying again (rate limits). The same number
            is in the `Retry-After` header.
          example: 60
        details:
          type: object
          additionalProperties: true
          description: >-
            More about the error: the fields that failed, a limit that was
            reached.
        correlationId:
          type: string
          description: Quote this when you ask support about the call.
          example: req_123e4567-e89b-12d3-a456-426614174000
        timestamp:
          type: string
          format: date-time
          example: '2026-10-15T10:00:00.000Z'
    PartnerStorageUsageTotals:
      type: object
      description: What a group of files weigh, and how much of it is kept where.
      required:
        - fileCount
        - totalBytes
        - widgeticStorageBytes
        - partnerStorageBytes
      properties:
        fileCount:
          type: integer
          format: int64
        totalBytes:
          type: integer
          format: int64
          description: The size of all the files together, in bytes
        widgeticStorageBytes:
          type: integer
          format: int64
          description: The part of `totalBytes` that is kept in Widgetic's storage
        partnerStorageBytes:
          type: integer
          format: int64
          description: >-
            The part of `totalBytes` that is kept in your own storage
            destination
      example:
        fileCount: 42
        totalBytes: 42
        widgeticStorageBytes: 42
        partnerStorageBytes: 42
    PartnerStorageUsageOfManagedUser:
      type: object
      description: >
        The files filed under one managed user. The row with a null
        `managedUserId` is the files that are not filed under any: your own, and
        the ones uploaded without naming a managed user.
      required:
        - managedUserId
        - externalId
        - name
        - isActive
        - fileCount
        - totalBytes
        - widgeticStorageBytes
        - partnerStorageBytes
        - lastUploadAt
      properties:
        managedUserId:
          type: string
          format: uuid
          nullable: true
          description: >-
            Widgetic's id for the managed user. Null for the files that are not
            filed under one.
        externalId:
          type: string
          nullable: true
          description: Your own identifier for the managed user
        name:
          type: string
          nullable: true
        isActive:
          type: boolean
          nullable: true
          description: False when the managed user is switched off
        fileCount:
          type: integer
          format: int64
        totalBytes:
          type: integer
          format: int64
        widgeticStorageBytes:
          type: integer
          format: int64
        partnerStorageBytes:
          type: integer
          format: int64
        lastUploadAt:
          type: string
          format: date-time
          nullable: true
          description: When the newest of these files was stored
      example:
        managedUserId: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        externalId: Example externalId
        name: Example name
        isActive: true
        fileCount: 42
        totalBytes: 42
        widgeticStorageBytes: 42
        partnerStorageBytes: 42
        lastUploadAt: '2026-01-15T09:30:00.000Z'
    PartnerReportPage:
      type: object
      description: Which part of a list the answer holds.
      required:
        - limit
        - offset
        - hasMore
      properties:
        limit:
          type: integer
          description: How many rows the page can hold at most
        offset:
          type: integer
          description: How many rows were skipped before this page
        hasMore:
          type: boolean
          description: >-
            True when more rows follow this page. Ask again with `offset` raised
            by `limit`.
      example:
        limit: 42
        offset: 42
        hasMore: true
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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