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

# Update Items

> This API updates items with new attribute values. Attributes must adhere to the data type defined.


#### Rate Limit

* Request limit: You can update 100 items per minute OR 1000 items per hour. You can update up to 50 items per request.

* Payload size limit: 5 MB only when Content-Length header is provided.


## OpenAPI

````yaml /api/catalog/catalog.yaml patch /catalog/{catalog_id}/items
openapi: 3.0.3
info:
  title: MoEngage Catalog API
  description: >
    This API allows for the management of product and item catalogs, including
    **creation**, **attribute definition**, **item ingestion, updates,
    deletion**, and **retrieval**.


    Authentication is handled via **Basic Auth** (using your Workspace ID as
    username and API Key as password), and all requests additionally require the
    `MOE-APPKEY` header (Workspace ID).


    The API has a platform-wide rate limit of **100 requests/minute OR 1000
    requests/hour**, with a maximum payload size of **5MB**.
  x-mint:
    content: |
      #example 500 max #
  version: '1.0'
servers:
  - url: https://api-{dc}.moengage.com/v1
    variables:
      dc:
        default: '01'
        description: >-
          The ‘dc’ in the API Endpoint URL refers to the MoEngage Data Center
          (DC). MoEngage hosts each customer in a different DC. You can find
          your DC number and replace the value of ‘dc’ in the URL by referring
          to the DC and API endpoint mapping
          [here](/api/introduction#data-centers). Your MoEngage Data Center (DC)
          can be 01, 02, 03, 04, 05, 06, or 101.
security:
  - basicAuth: []
tags:
  - name: Catalog
    description: Operations related to creating and managing catalog schemas (attributes).
  - name: Items
    description: >-
      Operations related to ingesting, updating, and deleting items within a
      catalog.
paths:
  /catalog/{catalog_id}/items:
    patch:
      tags:
        - Items
      summary: Update Items
      description: >
        This API updates items with new attribute values. Attributes must adhere
        to the data type defined.
      operationId: updateCatalogItems
      parameters:
        - name: MOE-APPKEY
          in: header
          description: >-
            This is the Workspace ID of your MoEngage account that must be
            passed with the request. You can find it in the MoEngage dashboard
            at **Settings** > **Account** > **APIs** > **Workspace ID (earlier
            app id)**.
          required: true
          schema:
            type: string
        - $ref: '#/components/parameters/CatalogIdPath'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - items
              properties:
                items:
                  type: array
                  maxItems: 50
                  description: >-
                    An array of item updates. Each object must contain the item
                    `id` and the `attributes` to update.
                  items:
                    $ref: '#/components/schemas/ItemUpdate'
            example:
              items:
                - id: Existing_item_ID
                  attributes:
                    attribute_name: updated_value
                - id: test2
                  attributes:
                    price: 98
                    sale_start_date: '2025-08-27T19:26:38.00Z'
                    store_location: 12.9716,77.5946
      responses:
        '200':
          description: >-
            OK. The update request was processed. The response body contains
            details on valid and invalid item counts.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/IngestUpdateResponse'
              example:
                message:
                  valid:
                    count: 1
                  invalid:
                    count: 8
                    details:
                      - error-id: item-not-found
                        message: >-
                          Item with id %s not found in the catalog. Please check
                          the item id and try again.
                        count: 1
                        document_ids:
                          - '567890'
                      - error-id: invalid-attributes
                        message: >-
                          Some of the attributes are not defined in the catalog
                          schema: (shipping_city)
                        count: 2
                        document_ids:
                          - '312'
                          - '8291379'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '413':
          $ref: '#/components/responses/PayloadTooLarge'
        '429':
          $ref: '#/components/responses/TooManyRequests'
components:
  parameters:
    CatalogIdPath:
      name: catalog_id
      in: path
      required: true
      description: The unique identifier for the catalog, obtained during catalog creation.
      schema:
        type: string
  schemas:
    ItemUpdate:
      type: object
      required:
        - id
        - attributes
      properties:
        id:
          type: string
          description: The unique ID of the item to update.
        attributes:
          type: object
          description: |
            A key-value map of attributes to update for the item. The keys
            must match existing attributes in the catalog schema, and values
            must match the defined data types.
          additionalProperties: true
          example:
            price: 24.99
            in_stock: false
    IngestUpdateResponse:
      type: object
      properties:
        message:
          type: object
          properties:
            valid:
              type: object
              properties:
                count:
                  type: integer
                  description: The number of items successfully processed.
            invalid:
              type: object
              properties:
                count:
                  type: integer
                  description: The number of items that failed processing.
                details:
                  type: array
                  items:
                    type: object
                    properties:
                      error-id:
                        type: string
                        description: >-
                          A unique ID indicating the type of ingestion/update
                          failure.
                        example: duplicate-item-ids
                      message:
                        type: string
                        description: The reason for the failure.
                        example: Item ids within a catalog must be unique.
                      count:
                        type: integer
                        description: >-
                          The number of items that failed due to this specific
                          error.
                        example: 1
                      document_ids:
                        type: array
                        items:
                          type: string
                        description: The IDs of the items that failed.
                        example:
                          - item_id_xyz
    Error:
      type: object
      properties:
        error-code:
          type: string
          description: A machine-readable error code.
        message:
          type: string
          description: A human-readable description of the error.
  responses:
    BadRequest:
      description: >-
        Bad Request - The request is improperly formatted, or contains
        missing/invalid parameters.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            invalid-datatype:
              value:
                error-code: invalid-request
                message: The data type provided for some of the attributes is invalid.
            invalid-json:
              value:
                error-code: invalid-request
                message: >-
                  The request body is not a valid JSON. Please provide a valid
                  JSON request body.
            limit-exceeded:
              value:
                error-code: invalid-request
                message: >-
                  items size should be greater than 0 and less than or equal to
                  50
    Unauthorized:
      description: >-
        Unauthorized - The request does not have valid authentication
        credentials.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error-code: request-unauthenticated
            message: >-
              Your request is unauthorized. Please verify your credentials and
              try again.
    Forbidden:
      description: Forbidden - The client does not have access rights to the Catalog APIs.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error-code: request-denied
            message: Your account does not have access to the Catalog APIs.
    NotFound:
      description: Not Found - The specified resource (catalog) could not be found.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error-code: catalog-not-found
            message: >-
              We could not find any API based catalog for the provided catalog
              id.
    PayloadTooLarge:
      description: Payload Too Large - The request payload exceeds the 5MB limit.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error-code: payload-size-exceeded
            message: >-
              Your payload size exceeds the 5MB limit. Please reduce the payload
              size and try again.
    TooManyRequests:
      description: >
        Too Many Requests - The rate limit for the API has been exceeded.


        The following headers are returned in case of rate-limit breach:

        * **x-ratelimit-limit (integer)**: The maximum number of requests that
        the consumer is permitted to make in a given time window.

        * **x-ratelimit-remaining (integer)**: The number of requests remaining
        in the current rate limit window.

        * **x-ratelimit-reset (integer)**: The time at which the current rate
        limit window resets in UTC epoch seconds.
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic
      description: >
        Authentication is done via Basic Auth. This requires a base64-encoded
        string of your credentials in the format 'username:password'.


        - **Username**: Use your MoEngage workspace ID (also known as the App
        ID). You can find it in the MoEngage dashboard at **Settings** >
        **Account** > **APIs** > **Workspace ID (earlier app id)**.

        - **Password**: Use your API Key, which you can find within the
        **Campaign report/Business events/Custom templates/Catalog API/Inform
        Report** tile.


        For more information on authentication and getting your credentials,
        refer
        [here](https://www.moengage.com/docs/api/introduction#getting-your-credentials).

````