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

# Update Thread

> Mark read or unread, close, reopen, snooze, assign or pin a thread

Acts as **the user who created the key** and sends nothing to the contact. Pass at least one field. Booleans must be
JSON booleans (`true`, not `"true"`).

## Use Cases

* **Mark as handled**: `{ "markRead": true, "status": "closed" }`
* **Take a conversation**: `{ "assignTo": "me" }` assigns it to the key's user and clears the AI's handover request
* **Come back later**: `{ "status": "snoozed", "snoozedUntil": "2026-11-20T09:00:00Z" }`

## Permissions

The API key needs the **Inbox** permission.

## Common Errors

| Status | Cause | Solution |
| - | - | - |
| `400` | No field, a field of the wrong type, `snoozed` without a future `snoozedUntil` | Check the body |
| `403` | The user id in `assignTo` is not a member of the workspace | Use a `userId` from a thread's `assignedTo` |
| `404` | Unknown thread, or a thread of another workspace | Use a `threadId` from List Threads |


## OpenAPI

````yaml patch /public/v1/inbox/threads/{threadId}
openapi: 3.1.0
info:
  title: API Documentation
  description: Documentation for transactional and subscribe APIs
  version: 1.0.0
servers:
  - url: https://app.minimo.it
security:
  - bearerAuth: []
paths:
  /public/v1/inbox/threads/{threadId}:
    servers:
      - url: https://api.minimo.it
    patch:
      summary: Update an inbox thread
      description: >-
        Mark read or unread, close, reopen, snooze, assign or pin a thread. Acts
        as the user who created the key and sends nothing to the contact. Pass
        at least one field.
      operationId: updateInboxThread
      parameters:
        - name: threadId
          in: path
          required: true
          description: The `threadId` from List Threads or Search Threads.
          schema:
            type: integer
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                markRead:
                  type: boolean
                  description: '`true` = read, `false` = unread again.'
                status:
                  type: string
                  enum:
                    - open
                    - closed
                    - snoozed
                snoozedUntil:
                  type: string
                  format: date-time
                  description: 'Required with `status: "snoozed"`, in the future.'
                assignTo:
                  description: >-
                    `"me"`, a teammate's user id (from `assignedTo.userId`), or
                    `null` to unassign. Assigning notifies the person and clears
                    the AI's handover request.
                  oneOf:
                    - type: string
                      enum:
                        - me
                    - type: integer
                  nullable: true
                pinned:
                  type: boolean
                  description: Pin to the top of the inbox.
            example:
              markRead: true
              assignTo: me
      responses:
        '200':
          description: The updated thread
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: object
                    properties:
                      thread:
                        $ref: '#/components/schemas/InboxThread'
              example:
                data:
                  thread:
                    threadId: 1234
                    status: open
                    unreadMessages: 0
                    pinned: false
                    channels:
                      - whatsapp
                    contact:
                      contactId: 5678
                      name: Mario Rossi
                      email: null
                      phone: '393331234567'
                    assignedTo:
                      userId: 42
                      name: Giulia Bianchi
                    needsHuman: true
                    ai:
                      state: active
                      since: null
                    snoozedUntil: null
                    updatedAt: '2026-11-13T09:00:00.000Z'
                    lastMessage:
                      messageId: 90112
                      direction: inbound
                      channel: whatsapp
                      subject: null
                      preview: Can I talk to a person?
                      at: '2026-11-13T09:00:00.000Z'
        '400':
          description: '`INVALID_PARAMETERS`: a parameter of the wrong type or out of range.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InboxError'
        '401':
          description: Missing or invalid API key, or a key without the `Inbox` permission.
        '403':
          description: The user id in `assignTo` is not a member of the workspace.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InboxError'
        '404':
          description: Unknown thread, or a thread of another workspace.
      security:
        - bearerAuth: []
      x-codeSamples:
        - label: CLI
          lang: cURL
          source: |-
            curl --request PATCH \
              --url 'https://api.minimo.it/public/v1/inbox/threads/1234' \
              --header 'Authorization: Bearer {{BEARER_TOKEN}}' \
              --header 'Content-Type: application/json' \
              --data '{"markRead": true, "assignTo": "me"}'
        - lang: JavaScript
          source: >-
            const res = await
            fetch('https://api.minimo.it/public/v1/inbox/threads/1234', {
              method: 'PATCH',
              headers: {
                'Authorization': 'Bearer {{BEARER_TOKEN}}',
                'Content-Type': 'application/json',
              },
              body: JSON.stringify({"markRead": true, "assignTo": "me"}),
            });

            const { data } = await res.json();

            console.log(data);
        - lang: Python
          source: |-
            import requests

            res = requests.patch(
                'https://api.minimo.it/public/v1/inbox/threads/1234',
                headers={'Authorization': 'Bearer {{BEARER_TOKEN}}'},
                json={'markRead': True, 'assignTo': 'me'},
            )
            print(res.json())
components:
  schemas:
    InboxThread:
      type: object
      description: >-
        One conversation with one contact: email, WhatsApp, SMS and Telegram
        together. The MCP `minimo_inbox_*` tools return the same object.
      properties:
        threadId:
          type: integer
          example: 1234
        status:
          type: string
          enum:
            - open
            - closed
            - snoozed
        unreadMessages:
          type: integer
          example: 2
        pinned:
          type: boolean
        channels:
          type: array
          description: Channels this contact has used in the thread.
          items:
            type: string
            enum:
              - whatsapp
              - email
              - sms
              - telegram
        contact:
          type: object
          properties:
            contactId:
              type: integer
              example: 5678
            name:
              type: string
              nullable: true
              example: Mario Rossi
            email:
              type: string
              nullable: true
              example: mario@example.com
            phone:
              type: string
              nullable: true
              example: '393331234567'
        assignedTo:
          type: object
          nullable: true
          description: The teammate the thread is assigned to, `null` if nobody.
          properties:
            userId:
              type: integer
              example: 42
            name:
              type: string
              nullable: true
              example: Giulia Bianchi
        needsHuman:
          type: boolean
          description: The AI handed the thread over to a person.
        ai:
          type: object
          properties:
            state:
              type: string
              enum:
                - active
                - paused
                - disabled
              description: >-
                `active` = the AI answers. `paused` = a teammate replied or the
                AI handed over; the AI comes back after the assistant's pause
                time. `disabled` = off on this thread until it is turned on
                again.
            since:
              type: string
              format: date-time
              nullable: true
              description: When the AI paused (`paused` only).
        snoozedUntil:
          type: string
          format: date-time
          nullable: true
        updatedAt:
          type: string
          format: date-time
        lastMessage:
          type: object
          nullable: true
          properties:
            messageId:
              type: integer
              example: 90112
            direction:
              type: string
              enum:
                - inbound
                - outbound
              description: >-
                `inbound` = from the contact, `outbound` = from you, your team
                or your AI.
            channel:
              type: string
              enum:
                - whatsapp
                - email
                - sms
                - telegram
            subject:
              type: string
              nullable: true
              description: Email only.
            preview:
              type: string
              description: The text on one line, up to 280 characters.
            at:
              type: string
              format: date-time
    InboxError:
      type: object
      description: >-
        `message` is the code, `userMessage` a sentence you can show to a
        person.
      properties:
        status:
          type: string
          example: FAIL
        message:
          type: string
          example: WHATSAPP_WINDOW_CLOSED
        userMessage:
          type: string
          example: >-
            WhatsApp allows free text only within 24 hours of the contact's last
            WhatsApp message. Send an approved template instead.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: mn-API_CLIENT_ID-API_KEY

````

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