User Mentions

Overview

You can mention users in both activities and comments. When you include mentioned_user_ids, the API stores the mentions and returns enriched mentioned_users in the response. Optionally, you can create notification activities for mentioned users or send push notifications.

Adding user mentions

mentioned_user_ids can only contain existing user ids, you can use queryUsers endpoint to search for users to mention.

Please note that it's up to you to include user mentions (for example @Alice) in the activity/comment text, the Stream API won't modify these fields based on mentioned_user_ids.

Adding an activity with mentions

let activity = try await feed.addActivity(
    request: .init(
        text: "Hey @bob and @alice, check this out!",
        type: "post",
        mentionedUserIds: ["bob", "alice"],
        createNotificationActivity: true
    )
)
// activity.mentionedUsers contains enriched user objects

val activity = feed.addActivity(
    request = FeedAddActivityRequest(
        text = "Hey @bob and @alice, check this out!",
        type = "post",
        mentionedUserIds = listOf("bob", "alice"),
        createNotificationActivity = true
    )
)
// activity.data?.mentionedUsers contains enriched user objects

const response = await feed.addActivity({
  type: "post",
  text: "Hey @bob and @alice, check this out!",
  mentioned_user_ids: ["bob", "alice"],
  create_notification_activity: true,
});
// response.activity.mentioned_users contains enriched user objects

const response = await feed.addActivity({
  type: "post",
  text: "Hey @bob and @alice, check this out!",
  mentioned_user_ids: ["bob", "alice"],
  create_notification_activity: true,
});
// response.activity.mentioned_users contains enriched user objects

const response = await feed.addActivity({
  type: "post",
  text: "Hey @bob and @alice, check this out!",
  mentioned_user_ids: ["bob", "alice"],
  create_notification_activity: true,
});
// response.activity.mentioned_users contains enriched user objects

final activity = await feed.addActivity(
  request: FeedAddActivityRequest(
    text: 'Hey @bob and @alice, check this out!',
    type: 'post',
    mentionedUserIds: ['bob', 'alice'],
    createNotificationActivity: true,
  ),
);
// activity.mentionedUsers contains enriched user objects

const response = await client.feeds.addActivity({
  feeds: ["user:eric"],
  type: "post",
  text: "Hey @bob and @alice, check this out!",
  user_id: "eric",
  mentioned_user_ids: ["bob", "alice"],
  create_notification_activity: true,
});
// response.activity.mentioned_users contains enriched user objects

_, err = client.Feeds().AddActivity(context.Background(), &getstream.AddActivityRequest{
  Feeds:                    []string{"user:eric"},
  Type:                     "post",
  Text:                     getstream.PtrTo("Hey @bob and @alice, check this out!"),
  UserID:                   getstream.PtrTo("eric"),
  MentionedUserIDs:         []string{"bob", "alice"},
  CreateNotificationActivity: getstream.PtrTo(true),
})
if err != nil {
  log.Fatal("Error adding activity:", err)
}

AddActivityRequest request = AddActivityRequest.builder()
    .feeds(List.of("user:eric"))
    .type("post")
    .text("Hey @bob and @alice, check this out!")
    .userID("eric")
    .mentionedUserIDs(List.of("bob", "alice"))
    .createNotificationActivity(true)
    .build();

AddActivityResponse response = client.feeds().addActivity(request).execute().getData();
// response.getActivity().getMentionedUsers() contains enriched user objects

$response = $feedsClient->addActivity(
    new GeneratedModels\AddActivityRequest(
        feeds: ['user:eric'],
        type: 'post',
        text: 'Hey @bob and @alice, check this out!',
        userID: 'eric',
        mentionedUserIDs: ['bob', 'alice'],
        createNotificationActivity: true
    )
);
// $response->activity->mentionedUsers contains enriched user objects

var response = await _feedsV3Client.AddActivityAsync(
    new AddActivityRequest
    {
        Feeds = new[] { "user:eric" },
        Type = "post",
        Text = "Hey @bob and @alice, check this out!",
        UserID = "eric",
        MentionedUserIDs = new[] { "bob", "alice" },
        CreateNotificationActivity = true
    }
);
// response.Activity.MentionedUsers contains enriched user objects

response = client.feeds.add_activity(
    feeds=["user:eric"],
    type="post",
    text="Hey @bob and @alice, check this out!",
    user_id="eric",
    mentioned_user_ids=["bob", "alice"],
    create_notification_activity=True,
)
# response["activity"]["mentioned_users"] contains enriched user objects

request = GetStream::Generated::Models::AddActivityRequest.new(
  feeds: ['user:eric'],
  type: 'post',
  text: 'Hey @bob and @alice, check this out!',
  user_id: 'eric',
  mentioned_user_ids: ['bob', 'alice'],
  create_notification_activity: true
)

response = client.feeds.add_activity(request)
# response.activity.mentioned_users contains enriched user objects

Adding a comment with mentions

let comment = try await feed.addComment(
    request: .init(
        comment: "Thanks @bob for the tip!",
        objectId: "activity_123",
        objectType: "activity",
        mentionedUserIds: ["bob"],
        createNotificationActivity: true
    )
)
// comment.mentionedUsers contains enriched user objects

val comment = feed.addComment(
    request = ActivityAddCommentRequest(
        comment = "Thanks @bob for the tip!",
        activityId = "activity_123",
        mentionedUserIds = listOf("bob"),
        createNotificationActivity = true
    )
)
// comment.data?.mentionedUsers contains enriched user objects

const response = await client.addComment({
  comment: "Thanks @bob for the tip!",
  object_id: "activity_123",
  object_type: "activity",
  mentioned_user_ids: ["bob"],
  create_notification_activity: true,
});
// response.comment.mentioned_users contains enriched user objects

const response = await client.addComment({
  comment: "Thanks @bob for the tip!",
  object_id: "activity_123",
  object_type: "activity",
  mentioned_user_ids: ["bob"],
  create_notification_activity: true,
});
// response.comment.mentioned_users contains enriched user objects

const response = await client.addComment({
  comment: "Thanks @bob for the tip!",
  object_id: "activity_123",
  object_type: "activity",
  mentioned_user_ids: ["bob"],
  create_notification_activity: true,
});
// response.comment.mentioned_users contains enriched user objects

final comment = await feed.addComment(
  request: ActivityAddCommentRequest(
    comment: 'Thanks @bob for the tip!',
    activityId: 'activity_123',
    activityType: 'activity',
    mentionedUserIds: ['bob'],
    createNotificationActivity: true,
  ),
);
// comment.mentionedUsers contains enriched user objects

const response = await client.feeds.addComment({
  comment: "Thanks @bob for the tip!",
  object_id: "activity_123",
  object_type: "activity",
  user_id: "alice",
  mentioned_user_ids: ["bob"],
  create_notification_activity: true,
});
// response.comment.mentioned_users contains enriched user objects

_, err = client.Feeds().AddComment(context.Background(), &getstream.AddCommentRequest{
  Comment:                    "Thanks @bob for the tip!",
  ObjectID:                   "activity_123",
  ObjectType:                 "activity",
  UserID:                     getstream.PtrTo("alice"),
  MentionedUserIDs:           []string{"bob"},
  CreateNotificationActivity:  getstream.PtrTo(true),
})
if err != nil {
  log.Fatal("Error adding comment:", err)
}

AddCommentRequest request = AddCommentRequest.builder()
    .comment("Thanks @bob for the tip!")
    .objectID("activity_123")
    .objectType("activity")
    .userID("alice")
    .mentionedUserIDs(List.of("bob"))
    .createNotificationActivity(true)
    .build();

AddCommentResponse response = feeds.addComment(request).execute().getData();
// response.getComment().getMentionedUsers() contains enriched user objects

$response = $feedsClient->addComment(
    new GeneratedModels\AddCommentRequest(
        comment: 'Thanks @bob for the tip!',
        objectID: 'activity_123',
        objectType: 'activity',
        userID: 'alice',
        mentionedUserIDs: ['bob'],
        createNotificationActivity: true
    )
);
// $response->comment->mentionedUsers contains enriched user objects

var response = await _feedsV3Client.AddCommentAsync(
    new AddCommentRequest
    {
        Comment = "Thanks @bob for the tip!",
        ObjectID = "activity_123",
        ObjectType = "activity",
        UserID = "alice",
        MentionedUserIDs = new[] { "bob" },
        CreateNotificationActivity = true
    }
);
// response.Comment.MentionedUsers contains enriched user objects

response = client.feeds.add_comment(
    comment="Thanks @bob for the tip!",
    object_id="activity_123",
    object_type="activity",
    user_id="alice",
    mentioned_user_ids=["bob"],
    create_notification_activity=True,
)
# response["comment"]["mentioned_users"] contains enriched user objects

request = GetStream::Generated::Models::AddCommentRequest.new(
  comment: 'Thanks @bob for the tip!',
  object_id: 'activity_123',
  object_type: 'activity',
  user_id: 'alice',
  mentioned_user_ids: ['bob'],
  create_notification_activity: true
)

response = client.feeds.add_comment(request)
# response.comment.mentioned_users contains enriched user objects

Reading mentioned users

Activities and comments returned by the API include a mentioned_users array with enriched user objects (id, name, image, etc.). Use them to render @mentions in your UI.

// From activities
let feedResponse = try await feed.getOrCreate()
for activity in feedResponse.activities {
    if let mentioned = activity.mentionedUsers, !mentioned.isEmpty {
        print("Mentioned: \(mentioned.map(\.name).joined(separator: ", "))")
    }
}
// From comments (e.g. activity with latest replies)
let activity = try await feed.getActivity(activityId: "activity_123", withReactions: false, withReactionCounts: false, withRecentReplies: 10)
for comment in activity.latestReplies ?? [] {
    if let mentioned = comment.mentionedUsers, !mentioned.isEmpty {
        print("Comment mentioned: \(mentioned.map(\.name).joined(separator: ", "))")
    }
}

// From activities
feed.getOrCreate()
feed.state.activities.collect { activities ->
    activities.forEach { activity ->
        activity.mentionedUsers?.let { mentioned ->
            println("Mentioned: ${mentioned.joinToString { it.name }}")
        }
    }
}
// From comments
val activity = feed.getActivity("activity_123", withRecentReplies = 10)
activity.latestReplies?.forEach { comment ->
    comment.mentionedUsers?.let { mentioned ->
        println("Comment mentioned: ${mentioned.joinToString { it.name }}")
    }
}

// From activities
const { activities } = await feed.getOrCreate();
activities.forEach((activity) => {
  if (activity.mentioned_users?.length) {
    console.log(
      "Mentioned:",
      activity.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});
// From comments
const { activity } = await feed.getActivity(activityId, {
  withRecentReplies: 10,
});
(activity.latest_replies || []).forEach((comment) => {
  if (comment.mentioned_users?.length) {
    console.log(
      "Comment mentioned:",
      comment.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});

// From activities
const { activities } = await feed.getOrCreate();
activities.forEach((activity) => {
  if (activity.mentioned_users?.length) {
    console.log(
      "Mentioned:",
      activity.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});
// From comments
const { activity } = await feed.getActivity(activityId, {
  withRecentReplies: 10,
});
(activity.latest_replies || []).forEach((comment) => {
  if (comment.mentioned_users?.length) {
    console.log(
      "Comment mentioned:",
      comment.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});

// From activities
const { activities } = await feed.getOrCreate();
activities.forEach((activity) => {
  if (activity.mentioned_users?.length) {
    console.log(
      "Mentioned:",
      activity.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});
// From comments
const { activity } = await feed.getActivity(activityId, {
  withRecentReplies: 10,
});
(activity.latest_replies || []).forEach((comment) => {
  if (comment.mentioned_users?.length) {
    console.log(
      "Comment mentioned:",
      comment.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});

// From activities
await feed.getOrCreate();
for (final activity in feed.state.activities) {
  if (activity.mentionedUsers != null && activity.mentionedUsers!.isNotEmpty) {
    print('Mentioned: ${activity.mentionedUsers!.map((u) => u.name).join(', ')}');
  }
}
// From comments
final activity = await feed.getActivity(activityId, withRecentReplies: 10);
for (final comment in activity.latestReplies ?? []) {
  if (comment.mentionedUsers != null && comment.mentionedUsers!.isNotEmpty) {
    print('Comment mentioned: ${comment.mentionedUsers!.map((u) => u.name).join(', ')}');
  }
}

// From activities
const response = await client.feeds.getOrCreateFeed("user", "eric", {
  user_id: "eric",
});
response.activities.forEach((activity) => {
  if (activity.mentioned_users?.length) {
    console.log(
      "Mentioned:",
      activity.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});
// From comments
const activityResponse = await client.feeds.getActivity(activityId, {
  with_recent_replies: 10,
});
(activityResponse.activity.latest_replies || []).forEach((comment) => {
  if (comment.mentioned_users?.length) {
    console.log(
      "Comment mentioned:",
      comment.mentioned_users.map((u) => u.name).join(", "),
    );
  }
});

// From activities
resp, err := client.Feeds().GetOrCreateFeed(context.Background(), "user", "eric", &getstream.GetOrCreateFeedRequest{
  UserID: getstream.PtrTo("eric"),
})
if err != nil {
  log.Fatal(err)
}
for _, a := range resp.Data.Activities {
  if len(a.MentionedUsers) > 0 {
    names := make([]string, len(a.MentionedUsers))
    for i, u := range a.MentionedUsers {
      names[i] = u.Name
    }
    log.Println("Mentioned:", strings.Join(names, ", "))
  }
}
// From comments
activityResp, err := client.Feeds().GetActivity(context.Background(), activityID, &getstream.GetActivityRequest{
  WithRecentReplies: getstream.PtrTo(int32(10)),
})
if err != nil {
  log.Fatal(err)
}
for _, c := range activityResp.Data.Activity.LatestReplies {
  if len(c.MentionedUsers) > 0 {
    names := make([]string, len(c.MentionedUsers))
    for i, u := range c.MentionedUsers {
      names[i] = u.Name
    }
    log.Println("Comment mentioned:", strings.Join(names, ", "))
  }
}

// From activities
GetOrCreateFeedResponse response = feed.getOrCreate().execute().getData();
response.getActivities().forEach(activity -> {
  if (activity.getMentionedUsers() != null && !activity.getMentionedUsers().isEmpty()) {
    String names = activity.getMentionedUsers().stream()
        .map(UserResponse::getName)
        .collect(Collectors.joining(", "));
    System.out.println("Mentioned: " + names);
  }
});
// From comments
GetActivityResponse activityResponse = client.feeds().getActivity(activityId).withRecentReplies(10).execute().getData();
activityResponse.getActivity().getLatestReplies().forEach(comment -> {
  if (comment.getMentionedUsers() != null && !comment.getMentionedUsers().isEmpty()) {
    String names = comment.getMentionedUsers().stream()
        .map(UserResponse::getName)
        .collect(Collectors.joining(", "));
    System.out.println("Comment mentioned: " + names);
  }
});

// From activities
$response = $feedsClient->getOrCreateFeed('user', 'eric', new GetOrCreateFeedRequest(userID: 'eric'));
foreach ($response->activities as $activity) {
  if (!empty($activity->mentionedUsers)) {
    $names = array_map(fn($u) => $u->name, $activity->mentionedUsers);
    echo 'Mentioned: ' . implode(', ', $names) . PHP_EOL;
  }
}
// From comments
$activityResponse = $feedsClient->getActivity($activityId, new GetActivityRequest(withRecentReplies: 10));
foreach ($activityResponse->activity->latestReplies ?? [] as $comment) {
  if (!empty($comment->mentionedUsers)) {
    $names = array_map(fn($u) => $u->name, $comment->mentionedUsers);
    echo 'Comment mentioned: ' . implode(', ', $names) . PHP_EOL;
  }
}

// From activities
var response = await _feedsV3Client.GetOrCreateFeedAsync("user", "eric", new GetOrCreateFeedRequest { UserID = "eric" });
foreach (var activity in response.Activities) {
  if (activity.MentionedUsers?.Count > 0) {
    var names = string.Join(", ", activity.MentionedUsers.Select(u => u.Name));
    Console.WriteLine($"Mentioned: {names}");
  }
}
// From comments
var activityResponse = await _feedsV3Client.GetActivityAsync(activityId, new GetActivityRequest { WithRecentReplies = 10 });
foreach (var comment in activityResponse.Activity.LatestReplies ?? Array.Empty<CommentResponse>()) {
  if (comment.MentionedUsers?.Count > 0) {
    var names = string.Join(", ", comment.MentionedUsers.Select(u => u.Name));
    Console.WriteLine($"Comment mentioned: {names}");
  }
}

# From activities
response = client.feeds.get_or_create_feed("user", "eric", user_id="eric")
for activity in response["activities"]:
  mentioned = activity.get("mentioned_users") or []
  if mentioned:
    print("Mentioned:", ", ".join(u.get("name", "") for u in mentioned))
# From comments
activity_response = client.feeds.get_activity(activity_id, with_recent_replies=10)
for comment in activity_response.get("activity", {}).get("latest_replies") or []:
  mentioned = comment.get("mentioned_users") or []
  if mentioned:
    print("Comment mentioned:", ", ".join(u.get("name", "") for u in mentioned))

# From activities
response = client.feeds.get_or_create_feed('user', 'eric', GetStream::Generated::Models::GetOrCreateFeedRequest.new(user_id: 'eric'))
response.activities.each do |activity|
  next if activity.mentioned_users.nil? || activity.mentioned_users.empty?
  puts "Mentioned: #{activity.mentioned_users.map(&:name).join(', ')}"
end
# From comments
activity_response = client.feeds.get_activity(activity_id, GetStream::Generated::Models::GetActivityRequest.new(with_recent_replies: 10))
(activity_response.activity.latest_replies || []).each do |comment|
  next if comment.mentioned_users.nil? || comment.mentioned_users.empty?
  puts "Comment mentioned: #{comment.mentioned_users.map(&:name).join(', ')}"
end

Mentions in notification feed

Activities: When create_notification_activity is true, each mentioned user receives a mention notification in their notification feed.
Comments: When create_notification_activity is true, each mentioned user receives a comment_mention notification (the activity author does not get an extra notification for mentions; they already get a comment notification).

For updating or deleting activities/comments and managing mention notifications (e.g. handle_mention_notifications, delete_notification_activity), see Notification feeds.

Push notifications

Use the skip_push parameter to control if push notifications are sent to mentioned users or not. For more information check the Push notification guide that contains all relevant information about setting up push notification providers, customizing notifications and user preferences.

File Uploads

URL Previews