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

# Get All Compositions

> Retrieves all compositions with pagination support.

Pass `managedUserId` (Widgetic's id for one of your managed users) or `managedUserExternalId` (your own
identifier for the user) to list only the compositions made for that managed user. The compositions of
your other managed users, and your own, are left out. It combines with the other filters and with paging.
A managed user that is not yours, or does not exist, is answered with 404 and `MANAGED_USER_NOT_FOUND`.

An editor session with the `creator` surface may call this to list the compositions of ONE widget it
built: it must send `widgetId`, and the answer holds only the compositions made for the session's
managed user.




## OpenAPI

````yaml /openapi/widgetic-api-public.json get /compositions
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:
  /compositions:
    get:
      tags:
        - Compositions
      summary: Get All Compositions
      description: >
        Retrieves all compositions with pagination support.


        Pass `managedUserId` (Widgetic's id for one of your managed users) or
        `managedUserExternalId` (your own

        identifier for the user) to list only the compositions made for that
        managed user. The compositions of

        your other managed users, and your own, are left out. It combines with
        the other filters and with paging.

        A managed user that is not yours, or does not exist, is answered with
        404 and `MANAGED_USER_NOT_FOUND`.


        An editor session with the `creator` surface may call this to list the
        compositions of ONE widget it

        built: it must send `widgetId`, and the answer holds only the
        compositions made for the session's

        managed user.
      operationId: getAllCompositions
      parameters:
        - in: query
          name: page
          schema:
            type: integer
            minimum: 1
            default: 1
          description: Page number for pagination
        - in: query
          name: size
          schema:
            type: integer
            minimum: 1
            maximum: 100
            default: 20
          description: Number of items per page
        - in: query
          name: sort
          schema:
            type: string
            example: createdAt:desc
          description: >
            The order of the list, as `<field>:<asc|desc>`. The field is
            `createdAt`, `updatedAt`, `name` or `status`

            (the snake_case spelling, such as `created_at`, is read too). `asc`
            or `desc` alone orders by `createdAt`.

            Default: `createdAt:desc`. Any other field is a 400.
        - in: query
          name: widgetId
          schema:
            type: string
            format: uuid
          description: Filter compositions by widget ID
        - in: query
          name: workspace
          schema:
            type: string
            enum:
              - 'true'
              - 'false'
          description: Filter by workspace
        - in: query
          name: projectFolder
          schema:
            type: string
            format: uuid
          description: Only the compositions in this project (the project's id).
        - in: query
          name: status
          schema:
            type: string
            enum:
              - draft
              - published
              - archived
          description: >-
            Only the compositions in this status. Without it, every status is
            listed.
        - in: query
          name: managedUserId
          schema:
            type: string
            format: uuid
          description: >-
            List only the compositions made for this managed user (Widgetic's id
            for the user). Send this or `managedUserExternalId`, not both. Send
            it as `managedUserId`; the snake_case spelling `managed_user_id` is
            refused with a 400, not ignored.
        - in: query
          name: managedUserExternalId
          schema:
            type: string
            maxLength: 255
          description: >-
            List only the compositions made for the managed user you registered
            with this `externalId` (your own identifier for the user). Send this
            or `managedUserId`, not both.
        - $ref: '#/components/parameters/ManagedUserScopeId'
        - $ref: '#/components/parameters/ManagedUserScopeExternalId'
      responses:
        '200':
          description: List of compositions retrieved successfully
          content:
            application/json:
              schema:
                type: object
                properties:
                  success:
                    type: boolean
                  data:
                    type: array
                    items:
                      $ref: '#/components/schemas/Composition'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
                required:
                  - success
                  - data
        '400':
          description: >-
            A parameter is not valid (for example a `managedUserId` that is not
            a UUID, or both `managedUserId` and `managedUserExternalId`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: >-
            The managed user named by `managedUserId` or `managedUserExternalId`
            is not one of yours (`MANAGED_USER_NOT_FOUND`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
      x-code-samples:
        - lang: TypeScript
          label: TypeScript SDK
          source: >
            import { Configuration, CompositionsApi } from
            '@widgetic/api-sdk-ts';


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


            const compositionsApi = new CompositionsApi(config);


            try {
              const response = await compositionsApi.getAllCompositions({
                page: 1,
                size: 20,
                sort: 'createdAt:desc'
              });
              
              // The paging numbers are in meta
              console.log('Compositions:', response.data);
              console.log('Total:', response.meta?.total);
              console.log('Current page:', response.meta?.page);
            } catch (error) {
              if (error.response?.status === 401) {
                console.error('Authentication required');
              } else {
                console.error('Failed to fetch compositions:', error);
              }
            }
components:
  parameters:
    ManagedUserScopeId:
      in: header
      name: X-Managed-User-Id
      required: false
      description: >-
        The id Widgetic gave the managed user (`POST /managed-users`). Makes
        this call for one of your managed users, so that a mistake in your own
        code cannot reach another customer's work. Send this header, or the
        other one, never both. Left out, the call works on your whole account,
        as it always has. With it, the call reaches only that user's
        compositions and workflows: a list shows only theirs, a composition or a
        workflow the call makes is filed under them, and one of another user, or
        one that does not exist, answers `404` (the same answer, so the call
        cannot be used to find out what another customer has). A managed user
        that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty,
        repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`;
        an empty header is never read as no header. A call that is about the
        whole account, such as the list of your managed users, is refused with
        `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the
        header. Only your API key can send it. The header is a limit the call
        asks for: whoever holds the key can leave it out, so for a credential
        that a customer's browser holds, use an editor session. An
        `Idempotency-Key` is kept apart for each managed user.
      schema:
        type: string
        format: uuid
        example: 3f2b8c1e-7a4d-4e0b-9c55-2d1a6b7e8f90
    ManagedUserScopeExternalId:
      in: header
      name: X-Managed-User-External-Id
      required: false
      description: >-
        Your own id for the managed user (its `externalId`), when you do not
        keep Widgetic's. Makes this call for one of your managed users, so that
        a mistake in your own code cannot reach another customer's work. Send
        this header, or the other one, never both. Left out, the call works on
        your whole account, as it always has. With it, the call reaches only
        that user's compositions and workflows: a list shows only theirs, a
        composition or a workflow the call makes is filed under them, and one of
        another user, or one that does not exist, answers `404` (the same
        answer, so the call cannot be used to find out what another customer
        has). A managed user that is not yours answers `404` with
        `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is
        `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read
        as no header. A call that is about the whole account, such as the list
        of your managed users, is refused with `403` and
        `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header.
        Only your API key can send it. The header is a limit the call asks for:
        whoever holds the key can leave it out, so for a credential that a
        customer's browser holds, use an editor session. An `Idempotency-Key` is
        kept apart for each managed user.
      schema:
        type: string
        minLength: 1
        maxLength: 255
        example: customer-1042
  schemas:
    Composition:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: Unique identifier for the composition
          example: 123e4567-e89b-12d3-a456-426614174000
        creatorId:
          type: string
          format: uuid
          description: ID of the user who created the composition
          example: 123e4567-e89b-12d3-a456-426614174001
        widgetId:
          type: string
          format: uuid
          description: ID of the widget this composition is based on
          example: 123e4567-e89b-12d3-a456-426614174002
        name:
          type: string
          description: Name of the composition
          example: My Composition
        content:
          type: object
          description: Content data for the composition
          example:
            key: value
        contentVersion:
          type: integer
          description: >-
            Monotonic content version when the content_version migration is
            applied
          example: 3
        status:
          type: string
          description: Current status of the composition
          enum:
            - draft
            - published
            - archived
          example: draft
        createdAt:
          type: string
          format: date-time
          description: When the composition was created
          example: '2023-01-01T00:00:00Z'
        updatedAt:
          type: string
          format: date-time
          description: When the composition was last updated
          example: '2023-01-02T00:00:00Z'
        embedSettings:
          type: object
          description: Settings for embedding the composition
          example:
            width: 100%
            height: 500px
        design:
          type: object
          description: Design settings for the composition
          example:
            theme: light
            colors:
              primary: '#0066ff'
        databaseId:
          type: string
          format: uuid
          description: >-
            Legacy. The id of a Neon database that an earlier version made for
            this composition. A composition now keeps its tables in a schema of
            its own (named `comp_` followed by its id) in a database shared with
            other compositions, so new compositions have none.
          example: 123e4567-e89b-12d3-a456-426614174003
        projectId:
          type: string
          format: uuid
          description: ID of the project this composition belongs to
          example: 123e4567-e89b-12d3-a456-426614174004
        managedUserId:
          type: string
          format: uuid
          nullable: true
          description: >-
            The managed user the composition was made for, or null when it is
            your own. List one managed user's compositions with the
            `managedUserId` or `managedUserExternalId` query parameter of
            `getAllCompositions`.
          example: b7c8d9e0-1f2a-4b3c-8d4e-5f6a7b8c9d0e
        direct:
          type: boolean
          nullable: true
          description: >
            Whether the widget the composition is made from is drawn straight
            into the page, without a frame

            (`true`), or inside a frame (`false`). `null` when the widget has no
            published version yet. It is a

            fact about the widget's published version, so every composition of
            one widget answers the same, and it

            changes when you publish another version. It cannot be set. Only
            `getCompositionById` returns it:

            the other calls that return a composition leave it out, and so does
            that one on the rare occasion the

            answer could not be worked out just then (ask again).
          example: true
        lastEditedBy:
          type: object
          nullable: true
          description: >
            Who made the latest change to a composition a team shares (one filed
            under a project of an organization,

            or one made in a Shopify store's workspace), so that a teammate who
            opens it can be told "Anna changed

            this at 14:32" and a save that someone else got ahead of can say
            who. It is `null` when nobody can be

            named: a change made by a Widgetic service, through an editor
            session, by a partner's call made for one

            managed user, or one made before this was recorded.


            Only `getCompositionById` returns it, and only for a composition a
            team shares, and only to a person (a

            signed-in member or a key of one): a composition in a personal
            project leaves it out, and so does every

            answer given to an editor session or to a call made for one managed
            user. It is also left out on the rare

            occasion the team could not be worked out just then (ask again). The
            other calls that return a

            composition leave it out.


            It is not the same as `creatorId`, who made the composition, and the
            account behind a change is never

            part of the composition itself: this is the only place it is told.
          properties:
            id:
              type: string
              format: uuid
              description: The account that made the latest change
              example: 123e4567-e89b-12d3-a456-426614174001
            name:
              type: string
              nullable: true
              maxLength: 120
              description: >-
                The name on that account, or `null` when it has none or it could
                not be read just then. Never an email address.
              example: Anna
        lastEditedAt:
          type: string
          format: date-time
          nullable: true
          description: >-
            When that latest change was made. Present whenever `lastEditedBy`
            is.
          example: '2026-10-28T14:32:00Z'
      required:
        - id
        - creatorId
        - widgetId
        - name
        - content
        - status
        - createdAt
        - updatedAt
      example:
        id: 123e4567-e89b-12d3-a456-426614174000
        creatorId: 123e4567-e89b-12d3-a456-426614174001
        widgetId: 123e4567-e89b-12d3-a456-426614174002
        name: My Composition
        content:
          key: value
        contentVersion: 3
        status: draft
        createdAt: '2023-01-01T00:00:00Z'
        updatedAt: '2023-01-02T00:00:00Z'
        embedSettings:
          width: 100%
          height: 500px
        design:
          theme: light
          colors:
            primary: '#0066ff'
        databaseId: 123e4567-e89b-12d3-a456-426614174003
        projectId: 123e4567-e89b-12d3-a456-426614174004
        managedUserId: b7c8d9e0-1f2a-4b3c-8d4e-5f6a7b8c9d0e
        direct: true
        lastEditedBy: {}
        lastEditedAt: '2026-10-28T14:32:00Z'
    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).
    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'
    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'
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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