Activity Feeds v3 is in beta — try it out!

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]interface{}{
    "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]interface{}{
    "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]interface{}{
    "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]interface{}{
    "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->addReaction(
    "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->addReaction(
    "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['own_reactions'] ?? []) . "\n";
    echo "Latest reactions: " . json_encode($firstActivity['latest_reactions'] ?? []) . "\n";
    echo "Reaction groups: " . json_encode($firstActivity['reaction_groups'] ?? []) . "\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";
}

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