Reactions

Overview

You can react to both activities and comments. It’s possible to configure any reaction types that best fit your app.

When adding reactions and the enforce_unique flag is set to true, the existing reaction of a user will be overridden with the new reaction. Use this flag if you want to ensure users have a single reaction per each comment/activity. The default value is false, in which case users can have multiple reactions.

// Add a reaction to an activity
let reaction = try await feed.addReaction(
    activityId: "activity_123",
    request: .init(
        custom: ["emoji": "❤️"],
        type: "like"
    )
)
// Remove a reaction
_ = try await feed.deleteReaction(activityId: "activity_123", type: "like")

// Add a reaction to an activity
val reaction: Result<FeedsReactionData> = feed.addActivityReaction(
    activityId = "activity_123",
    request = AddReactionRequest(
        custom = mapOf("emoji" to "❤️"),
        type = "like",
        // Optionally override existing reaction
        enforceUnique = true
    )
)

// Remove a reaction
val deleteResult: Result<FeedsReactionData> = feed.deleteActivityReaction(
    activityId = "activity_123",
    type = "like"
)

// Add a reaction to an activity
const addResponse = await client.addActivityReaction({
  activity_id: "activity_123",
  type: "like",
  custom: {
    emoji: "❤️",
  },
  // Optionally override existing reaction
  enforce_unique: true,
});

console.log(addResponse.reaction);

// Adding a reaction without triggering push notifications
await client.addActivityReaction({
  activity_id: "activity_123",
  type: "like",
  custom: {
    emoji: "❤️",
  },
  skip_push: true,
});

// Add a reaction to a comment
await client.addCommentReaction({
  id: comment.id,
  type: "like",
  custom: {
    emoji: "👍",
  },
  // Optionally override existing reaction
  enforce_unique: true,
});

// Adding a comment reaction without triggering push notifications
await client.addCommentReaction({
  id: comment.id,
  type: "like",
  custom: {
    emoji: "👍",
  },
  skip_push: true,
});
const deleteResponse = await client.deleteActivityReaction({
  activity_id: activity.id,
  type: "like",
});
console.log(deleteResponse.reaction);

// Add a reaction to an activity
final reaction = await feed.addActivityReaction(
  activityId: 'activity_123',
  request: const AddReactionRequest(
    custom: {'emoji': '❤️'},
    type: 'like',
    // Optionally override existing reaction
    enforceUnique: true,
  ),
);
// Remove a reaction
await feed.deleteActivityReaction(activityId: 'activity_123', type: 'like');

// Add a reaction to an activity
const addResponse = await client.feeds.addActivityReaction({
  activity_id: "activity_123",
  type: "like",
  custom: {
    emoji: "❤️",
  },
  user_id: "reacting_user_id",
  // Optionally override existing reaction
  enforce_unique: true,
});

console.log(addResponse.reaction);

// Adding a reaction without triggering push notifications
await client.feeds.addActivityReaction({
  activity_id: "activity_123",
  type: "like",
  custom: {
    emoji: "❤️",
  },
  user_id: "reacting_user_id",
  skip_push: true,
});

// Add a reaction to a comment
await client.feeds.addCommentReaction({
  comment_id: "comment_456",
  type: "like",
  custom: {
    emoji: "👍",
  },
  user_id: "reacting_user_id",
  // Optionally override existing reaction
  enforce_unique: true,
});

// Adding a comment reaction without triggering push notifications
await client.feeds.addCommentReaction({
  comment_id: "comment_456",
  type: "like",
  custom: {
    emoji: "👍",
  },
  user_id: "reacting_user_id",
  skip_push: true,
});

const deleteResponse = await client.feeds.deleteActivityReaction({
  activity_id: "activity_123",
  type: "like",
  user_id: "reacting_user_id",
});

console.log(deleteResponse.reaction);

// Add a reaction to an activity
_, err = client.Feeds().AddReaction(context.Background(), activityID, &getstream.AddReactionRequest{
  Type:       "like",
  Custom: map[string]any{
    "emoji": "❤️",
  },
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error adding reaction:", err)
}

// Adding a reaction without triggering push notifications
_, err = client.Feeds().AddReaction(context.Background(), activityID, &getstream.AddReactionRequest{
  Type:       "like",
  Custom: map[string]any{
    "emoji": "❤️",
  },
  UserID:   getstream.PtrTo("john"),
  SkipPush: getstream.PtrTo(true),
})
if err != nil {
  log.Fatal("Error adding reaction without push:", err)
}

// Add a reaction to a comment
_, err = client.Feeds().AddCommentReaction(context.Background(), commentID, &getstream.AddCommentReactionRequest{
  Type:      "like",
  Custom: map[string]any{
    "emoji": "👍",
  },
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error adding comment reaction:", err)
}

// Adding a comment reaction without triggering push notifications
_, err = client.Feeds().AddCommentReaction(context.Background(), commentID, &getstream.AddCommentReactionRequest{
  Type:      "like",
  Custom: map[string]any{
    "emoji": "👍",
  },
  UserID:   getstream.PtrTo("john"),
  SkipPush: getstream.PtrTo(true),
})
if err != nil {
  log.Fatal("Error adding comment reaction without push:", err)
}

// Delete activity reaction
_, err = client.Feeds().DeleteActivityReaction(context.Background(), activityID, "like", &getstream.DeleteActivityReactionRequest{
  UserID:     getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error deleting activity reaction:", err)
}

AddReactionRequest reactionRequest =
    AddReactionRequest.builder().type("like").userID(testUserId).build();

AddReactionResponse response =
    feeds.addReaction(activityId, reactionRequest).execute().getData();

// Add a reaction to an activity
$response = $feedsClient->addActivityReaction(
    "activity_123",
    new GeneratedModels\AddReactionRequest(
        type: 'like',
        userID: 'user123',
        // Optionally override existing reaction
        enforceUnique: true,
        custom: (object)['emoji' => '❤️']
    )
);

// Adding a reaction without triggering push notifications
$response = $feedsClient->addActivityReaction(
    "activity_123",
    new GeneratedModels\AddReactionRequest(
        type: 'like',
        userID: 'user123',
        custom: (object)['emoji' => '❤️'],
        skipPush: true
    )
);

// Add a reaction to a comment
$response = $feedsClient->addCommentReaction(
    "comment_456",
    new GeneratedModels\AddCommentReactionRequest(
        type: 'like',
        userID: 'user123',
        // Optionally override existing reaction
        enforceUnique: true,
        custom: (object)['emoji' => '👍']
    )
);

// Adding a comment reaction without triggering push notifications
$response = $feedsClient->addCommentReaction(
    "comment_456",
    new GeneratedModels\AddCommentReactionRequest(
        type: 'like',
        userID: 'user123',
        custom: (object)['emoji' => '👍'],
        skipPush: true
    )
);

// Delete activity reaction
$response = $feedsClient->deleteActivityReaction(
    "activity_123",
    "like",
    "user123"
);

var response = await _feedsV3Client.AddReactionAsync(
    activityId,
    new AddReactionRequest
    {
        Type = "like",
        UserID = _testUserId
    }
);

response = self.client.feeds.add_reaction(
    activity_id, type="like", user_id=self.test_user_id
)

# Add a reaction to an activity
reaction_request = GetStream::Generated::Models::AddReactionRequest.new(
  type: 'like',
  user_id: 'user123',
  custom: {
    emoji: '❤️'
  }
)

response = client.feeds.add_reaction(activity_id, reaction_request)

# Adding a reaction without triggering push notifications
reaction_request_skip_push = GetStream::Generated::Models::AddReactionRequest.new(
  type: 'like',
  user_id: 'user123',
  custom: {
    emoji: '❤️'
  },
  skip_push: true
)

response = client.feeds.add_reaction(activity_id, reaction_request_skip_push)

# Add a reaction to a comment
comment_reaction_request = GetStream::Generated::Models::AddCommentReactionRequest.new(
  type: 'like',
  user_id: 'user123',
  custom: {
    emoji: '👍'
  }
)

response = client.feeds.add_comment_reaction(comment_id, comment_reaction_request)

# Delete activity reaction
response = client.feeds.delete_activity_reaction(activity_id, 'like', 'user123')

Overview of the reaction model

FeedsReactionResponse

Name	Type	Description	Constraints
`activity_id`	`string`	ID of the activity that was reacted to	Required
`comment_id`	`string`	ID of the comment that was reacted to	-
`created_at`	`number`	When the reaction was created	Required
`custom`	`object`	Custom data for the reaction	-
`type`	`string`	Type of reaction	Required
`updated_at`	`number`	When the reaction was last updated	Required
`user`	`UserResponse`	User who created the reaction	Required

By default creating a reaction doesn’t create an activity.

When you read a feed the reactions are included. Here’s an example:

let feedData = try await feed.getOrCreate()
// Last 15 reactions on the first activity
print(feed.state.activities[0].latestReactions)
// Count of reactions by type
print(feed.state.activities[0].reactionGroups)

feed.getOrCreate()
feed.state.activities.collect { activities ->
    // Last 15 reactions on the first activity
    println(activities.first().latestReactions)
    // Count of reactions by type
    println(activities.first().reactionGroups)
}

const feed = client.feed("user", "sara");
await feed.getOrCreate();

console.log(feed.state.getLatestValue().activities?.[0].own_reactions);
console.log(feed.state.getLatestValue().activities?.[0].latest_reactions);
console.log(feed.state.getLatestValue().activities?.[0].reaction_groups);

final feedData = await feed.getOrCreate();
// Last 15 reactions on the first activity
print(feed.state.activities[0].latestReactions);
// Count of reactions by type
print(feed.state.activities[0].reactionGroups);

const feed = client.feeds.feed("user", "sara");
const response = await feed.getOrCreate({ user_id: "sara" });

console.log(response.activities[0].own_reactions);
console.log(response.activities[0].latest_reactions);
console.log(response.activities[0].reaction_groups);

feed := client.Feeds().Feed("user", "john")
feedResponse, err := feed.GetOrCreate(context.Background(), &getstream.GetOrCreateFeedRequest{
  UserID:          getstream.PtrTo("john"),
})

fmt.Println(feedResponse.Data.Activities[0].OwnReactions)
fmt.Println(feedResponse.Data.Activities[0].LatestReactions)
fmt.Println(feedResponse.Data.Activities[0].ReactionGroups)

Map<String, Object> filter = new HashMap<>();
filter.put("reaction_type", "like");

QueryActivityReactionsRequest queryRequest =
    QueryActivityReactionsRequest.builder().limit(10).filter(filter).build();

QueryActivityReactionsResponse response =
    feeds.queryActivityReactions(activityId, queryRequest).execute().getData();

// Get feed data with reactions
$feedResponse = $feedsClient->getOrCreateFeed(
    "user",
    "sara",
    new GeneratedModels\GetOrCreateFeedRequest(
        userID: "sara"
    )
);

// Access reaction data from activities
$activities = $feedResponse->getData()->activities;
if (!empty($activities)) {
    $firstActivity = $activities[0];
    echo "Own reactions: " . json_encode($firstActivity->ownReactions ?? []) . "\n";
    echo "Latest reactions: " . json_encode($firstActivity->latestReactions ?? []) . "\n";
    echo "Reaction groups: " . json_encode($firstActivity->reactionGroups ?? []) . "\n";
}

// Query reactions to a specific activity
$response = $feedsClient->queryActivityReactions(
    "activity_123",
    new GeneratedModels\QueryActivityReactionsRequest(
        limit: 10,
        filter: (object)['reaction_type' => 'like']
    )
);

var response = await _feedsV3Client.QueryActivityReactionsAsync(
    activityId,
    new QueryActivityReactionsRequest
    {
        Limit = 10,
        Filter = new Dictionary<string, object> { ["reaction_type"] = "like" }
    }
);

response = self.client.feeds.query_activity_reactions(
    activity_id, limit=10, filter={"type": "like"}
)

# Query reactions to a specific activity
query_request = GetStream::Generated::Models::QueryActivityReactionsRequest.new(
  limit: 10,
  filter: {
    reaction_type: 'like'
  }
)

response = client.feeds.query_activity_reactions(activity_id, query_request)

# Access reaction data
puts response.reactions
puts response.reaction_groups

Querying Reactions

You can query reactions to both activities and comments. Here are some examples:

// Query reactions to a specific activity
val activityReactionList = client.activityReactionList(
    ActivityReactionsQuery(
        activityId = "activity-123",
        filter = ActivityReactionsFilterField.reactionType.equal("like"),
    )
)
activityReactionList.get()
activityReactionList.state.reactions.collect { reactions ->
    // Handle activity reactions
}

// Query reactions to a specific comment
val commentReactionList = client.commentReactionList(
    CommentReactionsQuery(
        commentId = "comment-456",
        filter = CommentReactionsFilterField.reactionType.equal("like"),
    )
)
commentReactionList.get()
commentReactionList.state.reactions.collect { reactions ->
    // Handle comment reactions
}

// Query reactions to a specific activity
$response = $feedsClient->queryActivityReactions(
    "activity_123",
    new GeneratedModels\QueryActivityReactionsRequest(
        limit: 10,
        filter: (object)['reaction_type' => 'like']
    )
);

// Handle activity reactions
$reactions = $response->getData()->reactions;
foreach ($reactions as $reaction) {
    echo "Reaction: " . $reaction->type . " by " . $reaction->user->id . "\n";
}

// Query reactions to a specific comment
$response = $feedsClient->queryCommentReactions(
    $commentId,
    new GeneratedModels\QueryCommentReactionsRequest(
        limit: 10,
        filter: (object)['reaction_type' => 'like']
    )
);

// Handle comment reactions
$reactions = $response->getData()->reactions;
foreach ($reactions as $reaction) {
    echo "Comment reaction: " . $reaction->type . " by " . $reaction->user->id . "\n";
}

await client.queryActivityReactions({
  activity_id: activity.id,
  // Provide optional filters
  filter: {
    reaction_type: "like",
  },
});

await client.queryCommentReactions({
  id: comment.id,
  // Provide optional filters

  filter: {
    reaction_type: "like",
  },
});

await client.feeds.queryActivityReactions({
  activity_id: activity.id,
  // Provide optional filters
  filter: {
    reaction_type: "like",
  },
});

await client.feeds.queryCommentReactions({
  id: comment.id,
  // Provide optional filters

  filter: {
    reaction_type: "like",
  },
});

Reaction Queryable Built-In Fields

name	type	description	supported operations	example
`reaction_type`	string or list of strings	The type of reaction	`$in`, `$eq`	`{ reaction_type: { $in: [ 'like', 'heart', 'thumbs_up' ] } }`
`user_id`	string or list of strings	The ID of the user who created the reaction	`$in`, `$eq`	`{ user_id: { $eq: 'user_123' } }`
`created_at`	string, must be formatted as an RFC3339 timestamp	The time the reaction was created	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`

Stories

Bookmarks