Flag and Unflag Users

Use user flagging when a member reports another user for moderator review. Flagging does not block, ban, or delete the user; it records reporting state that moderation workflows can review. A member can hold several reports on the same user, one per report type plus one typeless report. You can send a simple flag (just the userId) or a structured report that says what is being reported and why, withdraw one report or all of them, and read back which reports the current member has filed so your UI can disable the options already used.

Flag and unflag take a userId on TypeScript, iOS, and Android; Flutter takes an AmityUser object. Flag state is read from the loaded user object on every platform.

Per-report-type unflag and the detailed flag-state result ship in the October 2026 SDK releases for TypeScript, iOS, and Android. Flutter keeps the boolean flag state and the all-at-once unflag.

Parameters

Operation	Required inputs	Platforms	Result shape
Flag user (typeless)	`userId`	TypeScript, iOS, Android	TypeScript returns `Promise<Amity.User>`; iOS async call throws on failure; Android returns `Completable`.
Report a profile field	`userId`, `field` (optional: `comment`)	TypeScript, iOS, Android	Same as flag user.
Report behavior	`userId`, `reason` (optional: `comment`)	TypeScript, iOS, Android	Same as flag user.
Flag user	`AmityUser` object	Flutter	Returns `Future<AmityUser>`.
Unflag user	`userId` (optional: `reportType`)	TypeScript, iOS, Android	TypeScript returns `Promise<boolean>`; iOS async call throws on failure; Android returns `Completable`.
Unflag user	`AmityUser` object	Flutter	Returns `Future<AmityUser>`. Withdraws all of your reports.
Quick yes/no	user object	TypeScript, iOS, Android, Flutter	`isFlaggedByMe` on the loaded user object: a boolean hint.
Check flag status	user object	TypeScript, iOS, Android	A flag-state result from `getUserFlagsByMe()` on the user: `isFlagByMe` plus the list of your own reports (`flags`). TypeScript `Promise<Amity.UserFlagByMe>`, iOS `AmityUserFlagByMe`, Android `Single<AmityUserFlagByMe>`.
Check flag status	`userId`	TypeScript, iOS	Deprecated repository call that still returns a boolean. TypeScript `Promise<boolean>`; iOS `Bool`.

Flag a user

Call the flag API when the current user reports another user without saying what or why. The server stores it as a typeless report.

Inputs

Platform	Method	Required inputs	Result shape
Android	`userRepository.flagUser(userId)`	`userId`	Returns `Completable`.
iOS	`userRepository.flagUser(withId:)`	`userId`	Async call that throws on failure.
TypeScript	`UserRepository.flagUser(userId)`	`userId`	Returns `Promise<Amity.User>` — the flagged user.
Flutter	`user.report().flag()`	`AmityUser` object	Returns `Future<AmityUser>`.

fun flagUser(userRepository: AmityUserRepository, userId: String) {
    userRepository.flagUser(userId = userId)
        .doOnComplete {
            Log.d("UserFlag", "User flagged")
        }
        .doOnError { error ->
            Log.e("UserFlag", "Flag failed", error)
        }
        .subscribe()
}

func flagUser() async {
    do {
        try await userRepository.flagUser(withId: "<user-id>")
        print("User flagged")
    } catch {
        print("Flag failed: \(error)")
    }
}

import { UserRepository } from '@amityco/ts-sdk';

async function flagUser(userId: string) {
  const flagged = await UserRepository.flagUser(userId);
  console.log('Flagged:', flagged);
}

Future<void> flagUser(AmityUser user) async {
  try {
    final updatedUser = await user.report().flag();
    print('Flagged user: ${updatedUser.userId}');
  } on AmityException catch (error) {
    print('Flag failed: ${error.message}');
  }
}

Report a profile field or behavior

When you want moderators to know what is being reported and why, use one of two calls on TypeScript, iOS, and Android:

Report a profile field with the field and an optional comment. A profile report never carries a reason.
Report behavior with a required reason and an optional comment.

Input	Applies to	Description
`field`	Profile report	The profile field being reported: display name, description (bio), or avatar.
`reason`	Behavior report	Required. A predefined reason from the shared content report-reason list.
`comment`	Both	Optional free text from the reporter, up to 300 characters after trimming. A blank comment is not sent.

Inputs

Platform	Method	Required inputs	Result shape
Android	`userRepository.flagUserProfile(userId, field, comment?)`	`userId`, `field` (`AmityUserProfileField`)	Returns `Completable`.
Android	`userRepository.flagUserBehavior(userId, reason, comment?)`	`userId`, `reason` (`AmityContentFlagReasonType`)	Returns `Completable`.
iOS	`userRepository.flagUserProfile(withId:field:comment:)`	`userId`, `field` (`AmityUserProfileField`)	Async call that throws on failure.
iOS	`userRepository.flagUserBehavior(withId:reason:comment:)`	`userId`, `reason` (`AmityContentFlagReasonType`)	Async call that throws on failure.
TypeScript	`UserRepository.flagUserProfile(userId, { field, comment? })`	`userId`, `field` (`UserProfileFieldEnum`)	Returns `Promise<Amity.User>`.
TypeScript	`UserRepository.flagUserBehavior(userId, { reason, comment? })`	`userId`, `reason` (`AmityContentFlagReasonType`)	Returns `Promise<Amity.User>`.

Profile fields

Your app decides the label to show the member.

Field	Suggested label	Android `AmityUserProfileField`	iOS `AmityUserProfileField`	TypeScript `UserProfileFieldEnum`
Display name	Username	`DISPLAY_NAME`	`.displayName`	`DISPLAY_NAME`
Description	Bio	`DESCRIPTION`	`.description`	`DESCRIPTION`
Avatar	Avatar	`AVATAR`	`.avatar`	`AVATAR`

Reasons

A behavior report takes a reason from the shared content report-reason list, the same one used when flagging posts, comments, and messages: community guidelines, child endangerment, harassment or bullying, self-harm or suicide, violence or threatening content, selling restricted items, sexual content or nudity, spam or scams, false information, or others. See Flag reasons for each platform’s identifiers. The reason never carries text: for Others, put the reporter’s explanation in comment. Use child endangerment (CHILD_ENDANGERMENT on Android, .childEndangerment on iOS, ChildEndangerment on TypeScript) when a user’s behavior endangers a child, including sharing suspected child sexual abuse material (CSAM).

Rules

A member holds one report per report type on a target: one per profile field, one for behavior, and one typeless. Reporting the same type again updates that report; reporting a different type adds a new one.
A comment longer than 300 characters after trimming is rejected before any request is sent.
Unflagging without a reportType removes all of your reports on that user. Pass a reportType to withdraw just one — see Unflag a user.
Any other rule the server enforces returns a validation error (HTTP 422).

Examples

Use the behavior call when the reporter picks a reason, and the profile call when they point at a field. Add a comment to either when the reporter gives extra detail.

// Report a user's behavior, with a reason and a comment
userRepository.flagUserBehavior(
    userId = userId,
    reason = AmityContentFlagReasonType.SPAM_OR_SCAMS,
    comment = "Repeatedly posting promo links"
).subscribe()

// Report a profile field (no reason)
userRepository.flagUserProfile(
    userId = userId,
    field = AmityUserProfileField.AVATAR
).subscribe()

// Report a user's behavior, with a reason and a comment
try await userRepository.flagUserBehavior(
    withId: "<user-id>",
    reason: .spamOrScams,
    comment: "Repeatedly posting promo links"
)

// Report a profile field (no reason)
try await userRepository.flagUserProfile(withId: "<user-id>", field: .avatar)

import { AmityContentFlagReasonType, UserProfileFieldEnum, UserRepository } from '@amityco/ts-sdk';

// Report a user's behavior, with a reason and a comment
await UserRepository.flagUserBehavior(userId, {
  reason: AmityContentFlagReasonType.SpamOrScams,
  comment: 'Repeatedly posting promo links',
});

// Report a profile field (no reason)
await UserRepository.flagUserProfile(userId, { field: UserProfileFieldEnum.AVATAR });

To report more than one aspect of the same profile (for example the avatar and the behavior), send a separate call for each. They are stored as distinct reports.

The earlier single call that took reportType, reason, and comment together (flagUser(userId, options) on TypeScript, flagUser(userId, reportType, reason, comment) on Android, and flagUser(withId:reportType:reason:comment:) on iOS) still works but is deprecated. Flagging with only a userId is not deprecated.

Unflag a user

Call the unflag API when the current user withdraws a report from another user. Without a reportType it withdraws every report you filed on that user. With a reportType it withdraws only that one and leaves your other reports in place.

Inputs

Platform	Method	Required inputs	Result shape
Android	`userRepository.unflagUser(userId, reportType?)`	`userId` (optional `reportType`)	Returns `Completable`.
iOS	`userRepository.unflagUser(withId:reportType:)`	`userId` (optional `reportType`)	Async call that throws on failure.
TypeScript	`UserRepository.unflagUser(userId, options?)`	`userId` (optional `reportType`)	Returns `Promise<boolean>`.
Flutter	`user.report().unflag()`	`AmityUser` object	Returns `Future<AmityUser>`. Withdraws all of your reports.

Which report is withdrawn

`reportType`	Withdraws
omitted	every report you filed on that user
`displayName`, `description`, `avatarFileId`, `behavior`	only your report of that type
`untyped`	only your typeless report (the one filed without a `reportType`)

untyped exists only for unflag. It names the typeless report, which the flag API never accepts as a type and which the flag-state result returns as reportType: null.

Withdrawing a report you never filed succeeds and changes nothing, so withdrawing twice is safe.
Other members’ reports on the same user are never affected, even of the same type.
After a per-type unflag you may still hold other reports on that user. Do not set a local “flagged by me” value to false after an unflag; read the flag state again instead.

fun unflagUser(userRepository: AmityUserRepository, userId: String) {
    // Withdraw every report you filed on this user
    userRepository.unflagUser(userId = userId)
        .doOnComplete {
            Log.d("UserFlag", "User unflagged")
        }
        .doOnError { error ->
            Log.e("UserFlag", "Unflag failed", error)
        }
        .subscribe()
}

fun withdrawBehaviorReport(userRepository: AmityUserRepository, userId: String) {
    // Withdraw only your behavior report; your other reports stay
    userRepository.unflagUser(
        userId = userId,
        reportType = AmityUserReportTypeFilter.BEHAVIOR
    ).subscribe()
}

fun withdrawTypelessReport(userRepository: AmityUserRepository, userId: String) {
    userRepository.unflagUser(
        userId = userId,
        reportType = AmityUserReportTypeFilter.UNTYPED
    ).subscribe()
}

func unflagUser() async {
    do {
        // Withdraw every report you filed on this user
        try await userRepository.unflagUser(withId: "<user-id>")
        print("User unflagged")
    } catch {
        print("Unflag failed: \(error)")
    }
}

func withdrawBehaviorReport() async throws {
    // Withdraw only your behavior report; your other reports stay
    try await userRepository.unflagUser(withId: "<user-id>", reportType: .behavior)
}

func withdrawTypelessReport() async throws {
    try await userRepository.unflagUser(withId: "<user-id>", reportType: .untyped)
}

import { UserReportTypeFilterEnum, UserRepository } from '@amityco/ts-sdk';

// Withdraw every report you filed on this user
async function unflagUser(userId: string) {
  const unflagged = await UserRepository.unflagUser(userId);
  console.log('Unflagged:', unflagged);
}

// Withdraw only your behavior report; your other reports stay
async function withdrawBehaviorReport(userId: string) {
  await UserRepository.unflagUser(userId, { reportType: UserReportTypeFilterEnum.BEHAVIOR });
}

// Withdraw only your typeless report
async function withdrawTypelessReport(userId: string) {
  await UserRepository.unflagUser(userId, { reportType: UserReportTypeFilterEnum.UNTYPED });
}

Future<void> unflagUser(AmityUser user) async {
  try {
    final updatedUser = await user.report().unflag();
    print('Unflagged user: ${updatedUser.userId}');
  } on AmityException catch (error) {
    print('Unflag failed: ${error.message}');
  }
}

Check which reports you filed on a user

Use the flag-state API to decide what to show: a “reported” badge, which report options to disable because the current member already used them, and a withdraw action per report. Only the current member’s own reports come back; other members’ reports are never exposed.

The repository call isUserFlaggedByMe is deprecated on TypeScript and iOS. It still works and still returns a boolean, so nothing breaks. Read flag state from the user object instead: isFlaggedByMe for a quick yes/no and getUserFlagsByMe() for the reports. Android never had a repository call; it adds getUserFlagsByMe() next to its existing isFlaggedByMe().

Which one to use

There are two ways to read the flag state. Pick by what the screen is doing.

When	Use	What you get
Drawing a feed row, a list item or a “reported” badge	The quick yes/no on the user object: Android `user.isFlaggedByMe()`, iOS `user.isFlaggedByMe`, TypeScript `user.isFlaggedByMe`, Flutter `user.isFlaggedByMe`	A boolean that returns immediately and never waits for a request. It is computed from the user data when the user is loaded.
Showing the options to flag or unflag	The flag-state call on the user object: Android, iOS, and TypeScript `user.getUserFlagsByMe()`	The exact reports (`isFlagByMe` and `flags`), read from the server. Call it only when you open those options, not for every row. When the quick yes/no is `false` it returns no reports without a request.

The quick yes/no is a hint built from data the user object already carries:

false is exact: you have not reported this user, as of the user object’s last update.
true means “maybe”. It can be true for a user you did not report, because of other members’ reports.
On TypeScript, iOS and Android, the SDK checks a true with the server in the background, once each time the user’s reports change, and remembers the answer. On TypeScript and iOS an observed user is delivered again with the checked value. On Android the checked value appears the next time the user updates.

Keep the quick yes/no current

A loaded user object is a snapshot: the yes/no is worked out from the user data it was built from, so a user object you already hold does not change after you flag or unflag. Observe the user instead, and read isFlaggedByMe from each update. The observer delivers a new user object after every flag or unflag, so your row or badge stays current without any request.

fun observeFlagState(userRepository: AmityUserRepository, userId: String): Disposable {
    // A new AmityUser arrives after you flag or unflag, so isFlaggedByMe() stays current
    return userRepository.getUser(userId = userId)
        .doOnNext { user: AmityUser ->
            val showReported = user.isFlaggedByMe()   // hint, no request
            // Update your row or badge here
        }
        .subscribe()
}

// Call dispose() on the returned Disposable when the screen no longer needs user updates.

var token: AmityNotificationToken?

func observeFlagState(userId: String) {
    // A new AmityUser arrives after you flag or unflag, so isFlaggedByMe stays current
    token = userRepository.getUser(userId).observe { liveObject, error in
        guard let user = liveObject.snapshot else { return }
        let showReported = user.isFlaggedByMe   // hint, no request
        // Update your row or badge here
    }
}

import { UserRepository } from '@amityco/ts-sdk';

// A new Amity.User arrives after you flag or unflag, so isFlaggedByMe stays current
const unsubscribe = UserRepository.getUser(userId, ({ data: user, loading }) => {
  if (loading || !user) return;
  const showReported = user.isFlaggedByMe; // hint, no request
  // Update your row or badge here
});

// Call unsubscribe() when the screen no longer needs user updates.

A report filed on another device shows once the user is refreshed. Call getUserFlagsByMe() when you need the exact state. getUserFlagsByMe() uses the hint of the user object you call it on: when that hint is false (including a false the SDK has already confirmed) it returns no reports without a request. Call it on the user you just observed, or on a freshly loaded one, not on an object you held from before a flag or unflag.

Load the user, then check

getUserFlagsByMe() is called on a user object, so get the user first. Use this when the options to flag or unflag open. A user you already hold from a list, a profile, or a member row works too; it carries the same members.

fun openReportOptions(userRepository: AmityUserRepository, userId: String) {
    // 1. Get the user. firstOrError() takes the first value and stops.
    userRepository.getUser(userId = userId)
        .firstOrError()
        // 2. Read the exact reports now
        .flatMap { user: AmityUser -> user.getUserFlagsByMe() }
        .doOnSuccess { result ->
            val isReported = result.isFlagByMe
            // Show "Unreport" when isReported is true, otherwise "Report"
        }
        .subscribe()
}

var token: AmityNotificationToken?

func openReportOptions(userId: String) {
    // 1. Get the user. observeOnce delivers the first value and stops.
    token = userRepository.getUser(userId).observeOnce { liveObject, error in
        guard let user = liveObject.snapshot else { return }

        Task {
            // 2. Read the exact reports now
            let result = try? await user.getUserFlagsByMe()
            let isReported = result?.isFlagByMe ?? false
            // Show "Unreport" when isReported is true, otherwise "Report"
        }
    }
}

import { UserRepository } from '@amityco/ts-sdk';

async function openReportOptions(user: Amity.User) {
  // The user comes from getUser, a list, or a member row; read the exact reports now
  const { isFlagByMe } = await user.getUserFlagsByMe();
  // Show "Unreport" when isFlagByMe is true, otherwise "Report"
}

const unsubscribe = UserRepository.getUser(userId, ({ data: user, loading }) => {
  if (loading || !user) return;
  openReportOptions(user);
});

Migrating from the repository call

The repository call still works but is deprecated on TypeScript and iOS. Replace it with the user object: isFlaggedByMe where you drew a badge from the boolean, and getUserFlagsByMe() where you need the exact answer.

// Before (deprecated, still returns Bool)
let isFlagged = try await userRepository.isUserFlaggedByMe(withId: userId)

// After
userRepository.getUser(userId).observeOnce { liveObject, error in
    guard let user = liveObject.snapshot else { return }
    Task {
        let isFlagged = try await user.getUserFlagsByMe().isFlagByMe
    }
}

import { UserRepository } from '@amityco/ts-sdk';

// Before (deprecated, still returns a boolean)
const isFlagged = await UserRepository.isUserFlaggedByMe(userId);

// After: a badge needs no request, the options sheet reads the exact state
UserRepository.getUser(userId, async ({ data: user, loading }) => {
  if (loading || !user) return;
  const showReported = user.isFlaggedByMe;
  const { isFlagByMe } = await user.getUserFlagsByMe();
});

Inputs

Platform	Method	Required inputs	Result shape
Android	`user.isFlaggedByMe()`	`AmityUser` object	Returns `Boolean`, a quick hint with no request.
Android	`user.getUserFlagsByMe()`	`AmityUser` object	Returns `Single<AmityUserFlagByMe>`.
iOS	`user.isFlaggedByMe`	`AmityUser` object	Returns `Bool`, a quick hint with no request.
iOS	`user.getUserFlagsByMe()`	`AmityUser` object	Returns `AmityUserFlagByMe` from an async call.
iOS	`userRepository.isUserFlaggedByMe(withId:)`	`userId`	Deprecated. Returns `Bool` from an async call.
TypeScript	`user.isFlaggedByMe`	`Amity.User` object	Returns `boolean`, a quick hint with no request.
TypeScript	`user.getUserFlagsByMe()`	`Amity.User` object	Returns `Promise<Amity.UserFlagByMe>`.
TypeScript	`UserRepository.isUserFlaggedByMe(userId)`	`userId`	Deprecated. Returns `Promise<boolean>`.
Flutter	`user.isFlaggedByMe`	`AmityUser` object	Returns `bool` from the loaded user model (yes/no only).

Result

Field	Type	Description
`isFlagByMe`	boolean	`true` when the current member holds any report on the user.
`flags`	list	The current member’s own reports on the user, in server order. Empty when not reported.
`flags[].reportType`	`displayName`, `description`, `avatarFileId`, `behavior`, or null	Which aspect was reported. `null` is the typeless report; withdraw it with `untyped`.
`flags[].reason`	string or null	The stored reason. Present on `behavior` reports.
`flags[].comment`	string or null	The stored reporter comment.
`flags[].createdAt`	date-time or null	When the report was filed. `null` for reports filed before report types existed.

Every field is always present; a field the report does not carry is null. The result is read from the server on each call and is not cached. The one exception: when the user’s quick yes/no is false, getUserFlagsByMe() returns no reports without a request.

fun checkFlagState(user: AmityUser) {
    // A hint with no request: false is exact; a true is checked with the server in the background
    Log.d("UserFlag", "Probably flagged by me: ${user.isFlaggedByMe()}")

    // The exact reports; skips the request when the hint is false
    user.getUserFlagsByMe()
        .doOnSuccess { result ->
            Log.d("UserFlag", "Flagged by me: ${result.isFlagByMe}")

            // Disable the report options the member already used
            val usedTypes = result.flags.map { it.reportType }.toSet()
            val canReportBio = AmityUserReportType.DESCRIPTION !in usedTypes
            Log.d("UserFlag", "Can report bio: $canReportBio")
        }
        .doOnError { error ->
            Log.e("UserFlag", "Flag-state check failed", error)
        }
        .subscribe()
}

func checkFlagState(user: AmityUser) async {
    // A hint with no request: false is exact; a true is checked with the server in the background
    print("Probably flagged by me: \(user.isFlaggedByMe)")

    do {
        // The exact reports; skips the request when the hint is false
        let result = try await user.getUserFlagsByMe()
        print("Flagged by me: \(result.isFlagByMe)")

        // Disable the report options the member already used
        let usedTypes = Set(result.flags.map { $0.reportType })
        let canReportBio = !usedTypes.contains(.description)
        print("Can report bio: \(canReportBio)")
    } catch {
        print("Flag-state check failed: \(error)")
    }
}

import { UserReportTypeEnum } from '@amityco/ts-sdk';

async function checkFlagState(user: Amity.User) {
  // A hint with no request: false is exact; a true is checked with the server in the background
  console.log('Probably flagged by me:', user.isFlaggedByMe);

  // The exact reports; skips the request when the hint is false
  const { isFlagByMe, flags } = await user.getUserFlagsByMe();
  console.log('Flagged by me:', isFlagByMe);

  // Disable the report options the member already used; null marks the typeless report
  const usedTypes = new Set(flags.map(flag => flag.reportType));
  const canReportBio = !usedTypes.has(UserReportTypeEnum.DESCRIPTION);
  console.log('Can report bio:', canReportBio);
}

void checkFlagState(AmityUser user) {
  final isFlaggedByMe = user.isFlaggedByMe;
  print('Flagged by me: $isFlaggedByMe');
}

Withdraw one of the listed reports

Each entry in flags maps to one unflag call. Pass its reportType, or untyped when the entry’s reportType is null.

On Android and iOS the reportType parameter of unflag is optional, and omitting it (or passing nil) withdraws all of your reports. An entry whose reportType is null is the typeless report: pass untyped, not nil.

fun withdrawAllListedReports(userRepository: AmityUserRepository, user: AmityUser) {
    user.getUserFlagsByMe()
        .flatMapCompletable { result ->
            Completable.concat(
                result.flags.map { flag ->
                    val filter = when (flag.reportType) {
                        AmityUserReportType.DISPLAY_NAME -> AmityUserReportTypeFilter.DISPLAY_NAME
                        AmityUserReportType.DESCRIPTION -> AmityUserReportTypeFilter.DESCRIPTION
                        AmityUserReportType.AVATAR -> AmityUserReportTypeFilter.AVATAR
                        AmityUserReportType.BEHAVIOR -> AmityUserReportTypeFilter.BEHAVIOR
                        null -> AmityUserReportTypeFilter.UNTYPED
                    }
                    userRepository.unflagUser(userId = user.getUserId(), reportType = filter)
                }
            )
        }
        .subscribe()
}

func withdrawAllListedReports(user: AmityUser) async throws {
    let result = try await user.getUserFlagsByMe()
    for flag in result.flags {
        let filter: AmityUserReportTypeFilter
        switch flag.reportType {
        case .displayName: filter = .displayName
        case .description: filter = .description
        case .avatarFileId: filter = .avatarFileId
        case .behavior: filter = .behavior
        case .none: filter = .untyped
        @unknown default: filter = .untyped
        }
        try await userRepository.unflagUser(withId: user.userId, reportType: filter)
    }
}

import { UserReportTypeFilterEnum, UserRepository } from '@amityco/ts-sdk';

async function withdrawAllListedReports(user: Amity.User) {
  const { flags } = await user.getUserFlagsByMe();
  for (const flag of flags) {
    // A null reportType is the typeless report; unflag selects it with 'untyped'
    const reportType = flag.reportType ?? UserReportTypeFilterEnum.UNTYPED;
    await UserRepository.unflagUser(user.userId, { reportType });
  }
}

Platform notes

Flagging is a report signal for moderation review; it does not automatically block, ban, or delete the user.
TypeScript, iOS, and Android flag and unflag by userId, and read flag state from the loaded user object (isFlaggedByMe and getUserFlagsByMe()). On TypeScript every user the SDK returns carries both members: a user from getUser, a user list, a member list, or a message preview.
Flutter flags and unflags through the loaded AmityUser object, withdraws all reports at once, and exposes a boolean flag state only.
The child endangerment reason for behavior reports ships in TypeScript 7.31.0 and in the next Android and iOS releases.
The repository call isUserFlaggedByMe is deprecated on TypeScript and iOS and keeps returning a boolean: Promise<boolean> on TypeScript, Bool on iOS. Android has no repository call.
isFlaggedByMe is computed from the user data when the user is loaded. false is exact; true can be a false positive, and it only reflects the user as of its last update. TypeScript, iOS and Android check a true with the server in the background. Use it to draw a feed row or a badge, and call getUserFlagsByMe() when you show the options to flag or unflag. getUserFlagsByMe() skips the request when isFlaggedByMe is false.
The backend returns the updated user, including its current flagCount, and the SDK saves it. Read flag state after a flag or unflag when your UI needs the updated per-report list.

Get User Information

Retrieve user details and flag status.

Roles and Permissions

Gate moderation actions with permission checks.

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Release Notes

Migration Guides

Support

Flag and Unflag Users

Parameters

Flag a user

Inputs

Report a profile field or behavior

Inputs

Profile fields

Reasons

Rules

Examples

Unflag a user

Inputs

Which report is withdrawn

Check which reports you filed on a user

Which one to use

Keep the quick yes/no current

Load the user, then check

Migrating from the repository call

Inputs

Result

Withdraw one of the listed reports

Platform notes

Get User Information

Roles and Permissions

​Parameters

​Flag a user

​Inputs

​Report a profile field or behavior

​Inputs

​Profile fields

​Reasons

​Rules

​Examples

​Unflag a user

​Inputs

​Which report is withdrawn

​Check which reports you filed on a user

​Which one to use

​Keep the quick yes/no current

​Load the user, then check

​Migrating from the repository call

​Inputs

​Result

​Withdraw one of the listed reports

​Platform notes

​Related topics

Get User Information

Roles and Permissions

Parameters

Flag a user

Inputs

Report a profile field or behavior

Inputs

Profile fields

Reasons

Rules

Examples

Unflag a user

Inputs

Which report is withdrawn

Check which reports you filed on a user

Which one to use

Keep the quick yes/no current

Load the user, then check

Migrating from the repository call

Inputs

Result

Withdraw one of the listed reports

Platform notes

Related topics