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

# Message Flagging

> Flag, unflag, and read the current user's flag state for chat messages.

Use message flagging when a signed-in user reports a chat message. The SDKs expose three client-side actions: flag a message, unflag a message, and check whether the current user has already flagged a fetched message.

Flagged messages are sent to the moderation backend. Keep product policy, review workflow, and enforcement copy outside the SDK integration layer so this page stays focused on the calls your app makes.

## Platform Surface

| Platform   | Flag with reason                                                                       | Unflag                                                      | Check current user's flag                             |
| ---------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------- | ----------------------------------------------------- |
| TypeScript | `MessageRepository.flagMessage(messageId, reason)`                                     | `MessageRepository.unflagMessage(messageId)`                | `MessageRepository.isMessageFlaggedByMe(messageId)`   |
| iOS        | `messageRepository.flagMessage(withId:reason:)`                                        | `messageRepository.unflagMessage(withId:)`                  | `messageRepository.isMessageFlaggedByMe(withId:)`     |
| Android    | `messageRepository.flagMessage(messageId, reason)`                                     | `messageRepository.unflagMessage(messageId)`                | `message.isFlaggedByMe()` on a fetched `AmityMessage` |
| Flutter    | `messageRepository.flagMessage(messageId:reason:)` or `message.flagWithReason(reason)` | `messageRepository.unflag(messageId)` or `message.unflag()` | `message.isFlaggedByMe` on a fetched `AmityMessage`   |

<Warning>
  The older Android no-reason `flagMessage(messageId)` overload and Flutter `flag(messageId)` repository method still exist for compatibility, but new docs should use reason-based flagging.
</Warning>

## Parameters

| Operation        | Parameter              | Required | Description                                                             |
| ---------------- | ---------------------- | -------- | ----------------------------------------------------------------------- |
| Flag             | `messageId`            | Yes      | Message ID to report.                                                   |
| Flag             | `reason`               | Yes      | Moderation reason enum or custom reason string, depending on platform.  |
| Unflag           | `messageId`            | Yes      | Message ID whose report should be removed for the current user.         |
| Check flag state | `messageId`            | Yes      | Message ID to check through the repository where supported.             |
| Check flag state | Fetched message object | Depends  | Android and Flutter expose `isFlaggedByMe` on a fetched `AmityMessage`. |

## Flag A Message

Flag a message with a moderation reason so your product can route it into review.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { ContentFlagReasonEnum, MessageRepository } from '@amityco/ts-sdk';

  const flagged = await MessageRepository.flagMessage(
    messageId,
    ContentFlagReasonEnum.SpamOrScams,
  );

  renderResults(flagged);
  ```

  ```swift iOS theme={null}
  try await messageRepository.flagMessage(
      withId: "message-id",
      reason: .spamOrScams
  )

  showSuccessMessage("Message flagged")
  ```

  ```kotlin Android theme={null}
  val disposable = messageRepository
      .flagMessage(
          messageId = messageId,
          reason = AmityContentFlagReason.SpamOrScams,
      )
      .subscribe(
          { showSuccessMessage() },
          { error -> handleFlagError(error) },
      )
  ```

  ```dart Flutter theme={null}
  final flaggedMessage = await AmityChatClient.newMessageRepository()
      .flagMessage(
        messageId: messageId,
        reason: AmityContentFlagReason.spamOrScams,
      );

  final isFlaggedByMe = flaggedMessage.isFlaggedByMe;
  ```
</CodeGroup>

## Use A Custom Reason

Use the `Others` reason only when your UI collects additional detail from the reporter.

Pass a custom reason string when the platform enum supports `Others` or direct string reasons.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { MessageRepository } from '@amityco/ts-sdk';

  const flagged = await MessageRepository.flagMessage(
    messageId,
    'Contains sensitive account information',
  );

  renderResults(flagged);
  ```

  ```swift iOS theme={null}
  try await messageRepository.flagMessage(
      withId: "message-id",
      reason: .others("Contains sensitive account information")
  )
  ```

  ```kotlin Android theme={null}
  val disposable = messageRepository
      .flagMessage(
          messageId = messageId,
          reason = AmityContentFlagReason.Others(
              "Contains sensitive account information",
          ),
      )
      .subscribe(
          { showSuccessMessage() },
          { error -> handleFlagError(error) },
      )
  ```

  ```dart Flutter theme={null}
  final flaggedMessage = await AmityChatClient.newMessageRepository()
      .flagMessage(
        messageId: messageId,
        reason: AmityContentFlagReason.others(
          'Contains sensitive account information',
        ),
      );

  final flagCount = flaggedMessage.flagCount;
  ```
</CodeGroup>

## Unflag A Message

Remove the current user's flag from a message when the user reverses the report action.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { MessageRepository } from '@amityco/ts-sdk';

  const unflagged = await MessageRepository.unflagMessage(messageId);

  renderResults(unflagged);
  ```

  ```swift iOS theme={null}
  try await messageRepository.unflagMessage(withId: "message-id")
  showSuccessMessage("Message unflagged")
  ```

  ```kotlin Android theme={null}
  val disposable = messageRepository
      .unflagMessage(messageId = messageId)
      .subscribe(
          { showSuccessMessage() },
          { error -> handleUnflagError(error) },
      )
  ```

  ```dart Flutter theme={null}
  final unflaggedMessage = await AmityChatClient.newMessageRepository()
      .unflag(messageId);

  final isFlaggedByMe = unflaggedMessage.isFlaggedByMe;
  ```
</CodeGroup>

## Check Flag State

TypeScript and iOS can ask the repository for the current user's flag state by message ID. Android and Flutter expose the state on fetched message objects.

Read flag state before rendering selected or disabled report controls.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { MessageRepository } from '@amityco/ts-sdk';

  const isFlaggedByMe =
    await MessageRepository.isMessageFlaggedByMe(messageId);

  updateUI({ isFlaggedByMe });
  ```

  ```swift iOS theme={null}
  let isFlaggedByMe = try await messageRepository
      .isMessageFlaggedByMe(withId: "message-id")

  showSuccessMessage(isFlaggedByMe)
  ```

  ```kotlin Android theme={null}
  messageRepository
      .getMessage(messageId = messageId)
      .subscribe(
          { fetchedMessage ->
              val isFlaggedByMe = fetchedMessage.isFlaggedByMe()
              updateMessageUI(messageId, isFlaggedByMe)
          },
          { error -> handleGeneralError(error) },
      )
  ```

  ```dart Flutter theme={null}
  final fetchedMessage = await AmityChatClient.newMessageRepository()
      .getMessage(messageId);

  final isFlaggedByMe = fetchedMessage.isFlaggedByMe;
  ```
</CodeGroup>

## Related Topics

<CardGroup cols={3}>
  <Card title="Query Messages" href="./messages/query-and-filter-messages" icon="list-filter">
    Refresh list state after flag or unflag actions.
  </Card>

  <Card title="Edit and Delete Messages" href="./messages/edit-and-delete-messages" icon="pen-to-square">
    Modify or soft-delete your own messages.
  </Card>

  <Card title="Content Moderation" href="/social-plus-sdk/chat/moderation-safety/content-moderation/overview" icon="shield-check">
    Connect message reports to your moderation operating model.
  </Card>
</CardGroup>