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

# List entries across a managed user's compositions

> Merges eligible tables (time and id columns) across the managed user's compositions in global time order, then compositionId, table, and id (byte order). Only tables with both a time and an id column take part. Rate limit 30 requests per minute.



## OpenAPI

````yaml /openapi/widgetic-api-public.json get /managed-users/{id}/entries
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:
  /managed-users/{id}/entries:
    get:
      tags:
        - Managed Users
      summary: List entries across a managed user's compositions
      description: >-
        Merges eligible tables (time and id columns) across the managed user's
        compositions in global time order, then compositionId, table, and id
        (byte order). Only tables with both a time and an id column take part.
        Rate limit 30 requests per minute.
      operationId: listManagedUserEntries
      parameters:
        - in: path
          name: id
          required: true
          schema:
            type: string
            format: uuid
        - in: query
          name: compositionId
          schema:
            type: string
            format: uuid
        - in: query
          name: table
          schema:
            type: string
            maxLength: 63
        - $ref: '#/components/parameters/CompositionEntryLimit'
        - $ref: '#/components/parameters/CompositionEntryOrder'
        - $ref: '#/components/parameters/CompositionEntrySince'
        - $ref: '#/components/parameters/CompositionEntryUntil'
        - $ref: '#/components/parameters/CompositionEntryCursor'
        - $ref: '#/components/parameters/CompositionEntryContextFilters'
        - $ref: '#/components/parameters/CompositionEntryColumnFilters'
      responses:
        '200':
          description: A page of entries across compositions
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ManagedUserEntriesPageSuccess'
              example:
                success: true
                data:
                  - compositionId: 11111111-1111-4111-8111-111111111111
                    table: ratings
                    id: '1'
                    createdAt: '2026-10-01T00:00:00.000000Z'
                    values: {}
                    context: null
                meta:
                  nextCursor: null
                  total: 120
                  compositionsConsidered: 2
                  moreCompositions: false
                  partial: true
        '400':
          description: Invalid cursor or filters
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: Missing partner scope or managed user access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: Managed user not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Rate limit exceeded
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
components:
  parameters:
    CompositionEntryLimit:
      in: query
      name: limit
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 25
    CompositionEntryOrder:
      in: query
      name: order
      description: >
        `desc` (the default) lists the newest entry first, `asc` the oldest.
        Entries are sorted by their time, then

        by their id (compared as text, byte by byte) in the same direction, so
        the order of two entries made at the

        same instant is always the same; an entry with no time counts as the
        oldest. A table with no time column is

        sorted by its id. The managed-user feed sorts by time, then by
        composition id, table and id.
      schema:
        type: string
        enum:
          - asc
          - desc
        default: desc
    CompositionEntrySince:
      in: query
      name: since
      description: >
        Only entries made at this time or later: `since` is INCLUSIVE (an entry
        made at exactly `since` is

        returned). A date and time with an offset, such as
        `2026-10-01T00:00:00Z`; anything else answers 400

        `INVALID_SINCE`. An entry with no time never matches, and a table with
        no time column answers 400

        `ENTRY_TABLE_HAS_NO_TIME`.
      schema:
        type: string
        format: date-time
    CompositionEntryUntil:
      in: query
      name: until
      description: >
        Only entries made before this time: `until` is EXCLUSIVE (an entry made
        at exactly `until` is NOT

        returned), so `since=A&until=B` followed by `since=B&until=C` counts
        every entry once. Same form and same

        refusals as `since` (400 `INVALID_UNTIL`).
      schema:
        type: string
        format: date-time
    CompositionEntryCursor:
      in: query
      name: cursor
      schema:
        type: string
    CompositionEntryContextFilters:
      in: query
      name: context
      description: >-
        Host context filters as `context[key]=value` (max 5 keys, counting
        dotted `context.key` too). Use `column.<name>=value` for columns whose
        names collide with reserved parameters.
      style: deepObject
      explode: true
      schema:
        type: object
        additionalProperties:
          type: string
    CompositionEntryColumnFilters:
      in: query
      name: filter
      description: >-
        Column filters as `filter[columnName]=value` (same meaning as bare
        `columnName=value` or `column.columnName=value`; max 10 column filters
        counting all spellings). A plain `filter=value` still filters a column
        named `filter`.
      style: deepObject
      explode: true
      schema:
        type: object
        additionalProperties:
          type: string
  schemas:
    ManagedUserEntriesPageSuccess:
      type: object
      required:
        - success
        - data
        - meta
      properties:
        success:
          type: boolean
          example: true
        data:
          type: array
          items:
            $ref: '#/components/schemas/ManagedUserEntryItem'
        meta:
          $ref: '#/components/schemas/ManagedUserEntriesMeta'
      example:
        success: true
        data:
          - Example ManagedUserEntryItem
        meta: null
    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'
    ManagedUserEntryItem:
      allOf:
        - $ref: '#/components/schemas/CompositionEntryItem'
        - type: object
          required:
            - compositionId
            - table
          properties:
            compositionId:
              type: string
              format: uuid
            table:
              type: string
    ManagedUserEntriesMeta:
      type: object
      required:
        - nextCursor
        - total
        - compositionsConsidered
        - moreCompositions
      properties:
        nextCursor:
          type: string
          nullable: true
        total:
          type: integer
        compositionsConsidered:
          type: integer
        moreCompositions:
          type: boolean
        partial:
          type: boolean
      example:
        nextCursor: Example nextCursor
        total: 42
        compositionsConsidered: 42
        moreCompositions: true
        partial: true
    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'
    CompositionEntryItem:
      type: object
      required:
        - id
        - values
        - context
        - createdAt
      properties:
        id:
          type: string
          nullable: true
        values:
          type: object
          additionalProperties: true
        context:
          type: object
          nullable: true
          additionalProperties: true
          description: >-
            The host context the entry was stored with: what the embedding page
            passed in, without the two keys of a signature (`widgetic_exp` and
            `widgetic_sig`), which are checked when the entry comes in and are
            never stored.
        createdAt:
          type: string
          format: date-time
          nullable: true
        truncatedColumns:
          type: array
          description: >
            The columns whose value was cut: a value longer than 20,000
            characters is cut there (a JSON value is

            cut as text, so it comes back as a string and no longer as an
            object), and its column is named here.

            Absent when nothing was cut.
          items:
            type: string
      example:
        id: Example id
        values: {}
        context: {}
        createdAt: '2026-01-15T09:30:00.000Z'
        truncatedColumns: []
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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