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

# Remove users from File Segment

> Removes a list of users from a CSV file from an existing file segment.



## OpenAPI

````yaml /api/custom-segments/custom-segments.yaml put /v2/custom-segments/file-segment/remove-users
openapi: 3.0.3
info:
  title: MoEngage Custom Segments API
  description: >
    Use the MoEngage Custom Segments API to create, update, and manage your file
    and filter segments.


    - **v2 API:** Manage File Segments and segment lifecycle
    (Archive/Unarchive).

    - **v3 API:** Create, read, update, and list filter-based Custom Segments.
  version: '3.0'
servers:
  - url: https://api-{dc}.moengage.com
    description: MoEngage API Endpoint
    variables:
      dc:
        description: Your account's Data Center (e.g., 01, 02, 03).
        default: '01'
        enum:
          - '01'
          - '02'
          - '03'
          - '04'
          - '05'
security:
  - basicAuth: []
tags:
  - name: Custom Segments - File
    description: >
      If you need to create segments by importing a large number of users, we
      recommend utilising the File segment API. This API allows you to easily
      generate a file segment by initiating a call to the file segment API
      endpoint. To proceed, you will need to compile a CSV file containing the
      relevant users (ensuring that the users are already present in MoEngage).
      It is essential to provide the public path of the file, which allows for
      downloading and identification of users in order to successfully create
      the file segment.


      Use the Custom File Segment API to:

      * Create a new Custom File Segment

      * Add Users to an existing Custom Segment

      * Remove Users from an existing Custom Segment

      * Replace Users from an existing Custom Segment
  - name: Custom Segments - Lifecycle
    description: >
      Archiving and unarchiving through APIs makes it easy to retrieve and reuse
      custom segments whenever required for purposes such as A/B testing,
      maintaining regulatory compliance, and improving system performance.


      You can access the archived segments and utilize them to analyze and
      market campaigns without the need to recreate them from scratch.
    x-mint:
      content: |

        <Warning>
          Archived segments will not be shown beyond 180 days.
        </Warning>
  - name: Custom Segments - Filters
    description: >
      If you need to create a segment based on the events or actions performed
      by your users on your application or website, the recommended approach is
      to use the filter segment API. With this API, you can create a custom
      segment by specifying the desired filter conditions.


      The filter segment API supports various operations, including create,
      update, get, and list, allowing you to effectively manage your segments
      based on specific criteria.
    x-mint:
      content: >
        ## Authentication

        Authentication is performed using Basic Auth. You must also provide the
        `MOE-APPKEY` header.


        ## Request Headers


        | Key | Required | Description |

        | :--- | :--- | :--- |

        | `Content-Type` | Yes | Set to `application/json`. |

        | `Authorization` | Yes | Basic Auth. `{"Authorization": "Basic
        Base64_ENCODED_WORKSPACEID_APIKEY="}` |

        | `MOE-APPKEY` | Yes | Your MoEngage App ID. Found in Settings ->
        Account -> APIs -> App ID. |


        ## FAQs


        <AccordionGroup>
          <Accordion title="How can I generate the payload for custom segment creation?">
            You can simply generate the payload from the MoEngage dashboard. Log in to the MoEngage dashboard and navigate to the **Test & Debug** -> **Segment Payload section**. Choose your filters and click on **Generate Payload**.
          </Accordion>
          <Accordion title="How do I get the id of a custom segment I created earlier but didn't save?">
            You can use the LIST Custom Segment API with the name query param filter to get the id of the custom segment.
          </Accordion>
          <Accordion title="Why am I getting 409 Conflict even with a different name?">
              Both the name and the definition of a custom segment are unique. If the definition of the custom segment in the request matches an existing segment, we return a conflict 409 error.
          </Accordion>
          <Accordion title="How do I know which existing segment is conflicting?">
            In the case of 409 Conflict, we return a conflicting name/id in the response payload. You can check the payload to get the existing custom segment with the same definition.
          </Accordion>
        </AccordionGroup>
paths:
  /v2/custom-segments/file-segment/remove-users:
    put:
      tags:
        - Custom Segments - File
      summary: Remove users from File Segment
      description: Removes a list of users from a CSV file from an existing file segment.
      operationId: removeUsersFromFileSegment
      parameters:
        - name: Content-Type
          in: header
          description: Select the file content type.
          required: true
          schema:
            type: string
            default: text/csv
            enum:
              - text/csv
              - application/csv
              - application/vnd.ms-excel
              - text/plain
              - application/octet-stream
              - binary/octet-stream
        - name: Database
          in: header
          description: Set the database from which the data is available (MOE-DBNAME).
          required: false
          schema:
            type: string
      requestBody:
        description: Details of the segment to update and the file URL of users to remove.
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UpdateSegmentRequestV2'
            example:
              name: custom_segment_unique_name
              attribute_name: unique_identifier
              attribute_type: string
              file_url: https://s3.amazonaws.com/Sample_GAIDs_remove.csv
              callback_url: http://example.com/moengage-callback
              emails:
                - user1@example.com
      responses:
        '202':
          description: Request accepted for processing.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiResponseSuccessV2'
              example:
                message: File-segment user-remove request accepted
                success: true
                cs_name: custom_segment_unique_name
        '400':
          description: Bad Request. Invalid payload format.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorV2'
              example:
                title: Invalid Request
                description: <message>
        '401':
          $ref: '#/components/responses/401_FileSegmentError'
        '404':
          $ref: '#/components/responses/404_FileSegmentNotFound'
        '429':
          $ref: '#/components/responses/429_FileSegmentRateLimit'
        '500':
          description: Server Errors. Something went wrong on MoEngage.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorV2'
              example:
                title: Internal Server Error
components:
  schemas:
    UpdateSegmentRequestV2:
      $ref: '#/components/schemas/BaseSegmentRequestV2'
      description: >-
        Schema for updating an existing file segment (add, remove, replace
        users).
    ApiResponseSuccessV2:
      type: object
      properties:
        message:
          type: string
          description: The status message of the request.
        success:
          type: boolean
          example: true
          description: Indicates if the request was accepted.
        cs_name:
          type: string
          description: The unique name of the custom segment being processed.
    ApiErrorV2:
      type: object
      properties:
        title:
          type: string
          description: A short title for the error.
    BaseSegmentRequestV2:
      type: object
      properties:
        name:
          type: string
          description: Name of the custom segment. Must be unique for creation.
        attribute_name:
          type: string
          description: >-
            Name of the user attribute to use as an identifier (e.g., 'ID',
            'email').
        attribute_type:
          type: string
          description: The data type of the attribute_name.
          enum:
            - string
            - double
        file_url:
          type: string
          format: uri
          description: A public, downloadable URL to a single-column CSV file.
        callback_url:
          type: string
          format: uri
          description: Callback URL to receive the result of segment processing.
        emails:
          type: array
          items:
            type: string
            format: email
          description: List of email IDs to receive segment processing response.
      required:
        - name
        - attribute_name
        - attribute_type
        - file_url
  responses:
    401_FileSegmentError:
      description: Unauthorized. Authentication or Authorization Failure.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiErrorV2'
          example:
            title: Authentication required
            description: <message>
    404_FileSegmentNotFound:
      description: Entity Not Found. The custom segment name does not exist.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiErrorV2'
          example:
            title: Entity Not Found
            description: >-
              Custom segment not found with the given name:
              <custom_segment_unique_name>
    429_FileSegmentRateLimit:
      description: >-
        Too Many Requests. The number or rate of requests exceeds the allowed
        limit.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiErrorV2'
          example:
            title: Too Many Requests
            description: <appropriate message>
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic
      description: >
        Basic Authentication using your **Workspace ID** (as username) and
        **Data API Key** (as password) from the MoEngage Dashboard.

````