Activities

Creating Activities

The example below shows how to create an activity and add it to a feed.

feedsClient := client.Feeds()
response, err := feedsClient.AddActivity(context.Background(), &getstream.AddActivityRequest{
	Type:   "post",
	Feeds:  []string{"user:john", "stock:apple"},
	Text:   getstream.PtrTo("apple stock will go up"),
	UserID: getstream.PtrTo("john"),
})
if err != nil {
	log.Fatal("Error adding activity:", err)
}
log.Printf("Activity added successfully: %+v", response)

Adding activities uses upsert logic. If the activity already exists, it will be updated with the new data.

You do not need to call getOrCreate on a feed before adding an activity to it. If you add an activity to a feed that does not exist yet, the feed is created automatically. This applies to both add activity and add activities (batch) requests.

The above example was quite simple. Here are a few more examples:

Image & Video

You can use Stream's CDN for storing and quickly accessing files attached to activities.

response, err := client.Feeds().AddActivity(context.Background(), &getstream.AddActivityRequest{
	Type:   "post",
	Feeds:  []string{"user:john"},
	Text:   getstream.PtrTo("look at NYC"),
	UserID: getstream.PtrTo("john"),
	Attachments: []getstream.Attachment{
		{
			AssetUrl: getstream.PtrTo("https://example.com/image.png"),
			Type:     getstream.PtrTo("image"),
			Title:    getstream.PtrTo("Amazing Video"),
			Custom: map[string]any{},
		},
	},
})

Sharing activities

When creating an activity it's possible to set parent_id, setting this field will increase the share_count of the parent activity. This feature lets you implement "retweets".

When reading an activity with parent id set, you can access the parent activity with activity.parent.

feedsClient := client.Feeds()
response, err := feedsClient.AddActivity(context.Background(), &getstream.AddActivityRequest{
	Type:   "post",
	Feeds:  []string{"user:john"},
	Text:   getstream.PtrTo("Couldn't agree more!"),
  ParentID:   getstream.PtrTo("<activity to share>"),
	UserID: getstream.PtrTo("john"),
})
if err != nil {
	log.Fatal("Error adding activity:", err)
}
log.Printf("Activity added successfully: %+v", response)

Restricting comment replies

When creating an activity it's possible to set who can add comments. Possible options:

  • Everyone (this is the default setting)
  • Only people I follow
  • Nobody

The activity author is always allowed to add comments regardless of the reply settings.

feedsClient := client.Feeds()
response, err := feedsClient.AddActivity(context.Background(), &getstream.AddActivityRequest{
	Type:          "post",
	Feeds:         []string{"user:john"},
	Text:          getstream.PtrTo("apple stock will go up"),
	UserID:        getstream.PtrTo("john"),
	RestrictReplies: getstream.PtrTo("people_i_follow"), // Options: "everyone", "people_i_follow", "nobody"
})
if err != nil {
	log.Fatal("Error adding activity:", err)
}

Activity request options

The following options can be provided when creating an activity:

Activity size limit

Total activity size (including built-in and custom fields) must not exceed 10KB (the limit is checked when writing activities, not when reading them). If your use case requires a larger payload, collections help attach data to activities without increasing activity size.

Reading Activities with Enrichment

When you read activities from feeds, they are automatically enriched with additional data:

  • Comments: The latest 5 top-level comments (replies not included by default)
  • Reactions: Recent reactions and reaction counts
  • User data: Information about the activity author
  • Collections: Any collections the activity references

To load more comments, replies, or additional data, use the dedicated loading methods described in the Comments and Reactions sections.

Overview of All Activity Fields

Adding Many Activities

You can also batch add activities. Here's an example:

activities := []getstream.ActivityRequest{
	{
		Type:   "post",
		Feeds:  []string{"user:123"},
		Text:   getstream.PtrTo("Batch activity 1"),
		UserID: getstream.PtrTo("john"),
	},
	{
		Type:   "post",
		Feeds:  []string{"user:456"},
		Text:   getstream.PtrTo("Batch activity 2"),
		UserID: getstream.PtrTo("alice"),
	},
}
response, err := client.Feeds().UpsertActivities(context.Background(), &getstream.UpsertActivitiesRequest{
	Activities: activities,
})

Visibility Levels

When creating an activity, you can provide a visibility to the activity:

Please note that activity visibility is not the same as feed visibility

  • public: marks the activity as public - everyone who can view feed content, can see it
  • private: marks the activity as private - only feed owner can see it
  • tag:mytag: marks the activity as only visible to followers/members with the permission to see this tag

This visibility system is very flexible and allows you to build:

  • Apps like Patreon where only certain levels of users can see your content
  • Apps like Strava where it's possible to share your activity with nobody, everyone or your followers
let privateActivity = try await feed.addActivity(
    request: .init(
        text: "Premium content",
        type: "post",
        visibility: .tag,
        visibilityTag: "premium"
    )
)
// Premium users can see full activity, others a preview

For all the details on tag visibility read the Membership levels guide.

Partial activity updates

A partial update can be used to set or unset specific fields and leave other fields unchanged. AKA a patch style update. Both set and unset can be used in the same request. The dotted-notation is also available for both set and unset for the custom field.

You can set run_activity_processors to true to run activity processors on the updated activity. Processors will only run if the activity text and/or attachments are changed. This flag defaults to false.

Interest tags behavior:

  • If run_activity_processors is true: New tags generated from text/image are appended to existing tags.
  • If run_activity_processors is false or not set: Existing tags are preserved unchanged.
// Partially set some fields
updateRequest := &getstream.UpdateActivityPartialRequest{
  UserID: stringPtr("<user id>"),
  Set: map[string]any{
    "text": "Japan has over 6,800 islands.",
  },
}

response, err := client.Feeds().UpdateActivityPartial(context.Background(), "123", updateRequest)
if err != nil {
  log.Fatal("Error updating activity:", err)
}
log.Println("Activity edited at:", response.Activity.EditedAt)

// Partially unset some fields
updateRequest := &getstream.UpdateActivityPartialRequest{
  UserID: stringPtr("<user id>"),
  Unset: []string{"custom.color"},
}

response, err = client.Feeds().UpdateActivityPartial(context.Background(), "123", updateRequest)
if err != nil {
  log.Fatal("Error updating activity:", err)
}
log.Println("Activity edited at:", response.Activity.EditedAt)

Batch Partial Activity Updates

You can perform partial updates on multiple activities in a single batch operation. This is more efficient than updating activities one by one when you need to update several activities at once.

// Update multiple activities with different changes
var partialUpdateRequest = new UpdateActivitiesPartialBatchRequest
{
    Changes = new List<UpdateActivityPartialChangeRequest>
    {
        new UpdateActivityPartialChangeRequest
        {
            ActivityID = activityId1,
            Set = new Dictionary<string, object>
            {
                ["text"] = "Updated text for activity 1",  // Update main text
                ["likes"] = 25,  // Update custom field
                ["status"] = "featured"  // Update custom field
            },
            Unset = new List<string> { "priority" }  // Remove custom field
        },
        new UpdateActivityPartialChangeRequest
        {
            ActivityID = activityId2,
            Set = new Dictionary<string, object>
            {
                ["text"] = "Updated text for activity 2",  // Update main text
                ["likes"] = 15,  // Update custom field
                ["status"] = "published"  // Update custom field
            },
            Unset = new List<string> { "views", "category" }  // Remove multiple custom fields
        }
    }
};

var response = await _feedsV3Client.UpdateActivitiesPartialBatchAsync(partialUpdateRequest);
Console.WriteLine($"Updated {response.Data.Activities.Count} activities");

This operation allows you to:

  • Update specific fields in multiple activities
  • Use both set (to update/add fields) and unset (to remove fields) operations
  • Process all changes in a single API call for better performance

Updatable Fields:

The following reserved fields can be updated:

  • text - Activity text content
  • attachments - Media attachments
  • visibility - Activity visibility level
  • visibility_tag - Visibility tag
  • expires_at - Expiration timestamp
  • filter_tags - Filter tags for querying
  • interest_tags - Interest tags
  • collection_refs - Collection references
  • feeds - Feeds the activity belongs to
  • mentioned_user_ids - Mentioned users
  • poll_id - Associated poll
  • Any custom fields (stored in custom object)

Note: The type field cannot be changed after an activity is created. Other immutable fields include id, user_id, created_at, etc.

Updating Activities

This example shows how to fully update an activity:

You can set run_activity_processors to true to run activity processors on the updated activity. Processors will only run if the activity text and/or attachments are changed. This flag defaults to false.

Interest tags behavior:

  • If run_activity_processors is false or not set, and no interest_tags are provided: interest_tags are set to an empty array.
  • If run_activity_processors is true and no interest_tags are sent: New tags are generated from text/image (replaces existing tags).
  • If run_activity_processors is true and interest_tags are sent: Generated tags are merged with the provided tags.
  • You can modify existing tags by providing them in the request before updating.
updateRequest := &getstream.UpdateActivityRequest{
  Text:   stringPtr("Updated text"),
  UserID: stringPtr("john"),
}

// NOTE: UpdateActivity does a full replace of the activity.
// Use UpdateActivityPartial if you only want to update specific fields.
response, err := client.Feeds().UpdateActivity(context.Background(), "123", updateRequest)
if err != nil {
  log.Fatal("Error updating activity:", err)
}
log.Println("Activity edited at:", response.Activity.EditedAt)

Deleting Activities

This example shows how to delete an activity:

// Delete a single activity (soft delete)
deleteRequest := &getstream.DeleteActivityRequest{
  HardDelete: boolPtr(false), // Soft delete
}

deleteResponse, err := client.Feeds().DeleteActivity(context.Background(), "123", deleteRequest)
if err != nil {
  log.Fatal("Error deleting activity:", err)
}
log.Printf("Activity deleted successfully: %+v", deleteResponse)

// Batch delete activities
batchDeleteRequest := &getstream.DeleteActivitiesRequest{
  Ids:        []string{"123", "456"},
  UserID:     stringPtr("john"),
  HardDelete: boolPtr(false), // Soft delete
}

batchDeleteResponse, err := client.Feeds().DeleteActivities(context.Background(), batchDeleteRequest)
if err != nil {
  log.Fatal("Error batch deleting activities:", err)
}
log.Printf("Activities batch deleted successfully: %+v", batchDeleteResponse)

Note: There are automatic side effects when deleting activities that are irreversible.

  • Bookmarks related to the deleted activity are removed.
  • Pins related to the deleted activity are removed.

Restoring an activity will not bring back any of these.

Restore Activity

If an activity was soft-deleted, it can be restored using the restore endpoint. Only the activity owner can restore their own activities (for client-side requests). Hard-deleted activities cannot be restored.

// Restore a soft-deleted activity
restoreResponse, err := client.Feeds().RestoreActivity(context.Background(), "123", &getstream.RestoreActivityRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error restoring activity:", err)
}
log.Printf("Activity restored successfully: %+v", restoreResponse)

When an activity is restored a feeds.activity.restored event is sent to all feeds the activity is part of. There is no default event handler in client-side SDKs but it's possible to add a custom handler.

Get activity

Fetching a single activity.

When implementing an activity details page on the client-side it may be important to receive updates for the activity. The activity state is automatically updated on HTTP requests initiated from the client. To receive real-time updates (to receive updates from other users, for example someone else liked this post), you have to watch the feed the activity belongs to (or one of the feeds, in case it belongs to multiple feeds).

When fetching an activity that belongs to multiple feeds activity.current_feed will be empty. If you wish to display feed information alongside the activity, you have to fetch any of the containing feeds with a separate API call.

const activityWithStateUpdates =
  client.activityWithStateUpdates(activityId);
await activityWithStateUpdates.get({
  // Optionally fetch comments too
  comments: {
    limit: 10,
    depth: 2,
  },
});

// Subscribe to state updates
activityWithStateUpdates.state.subscribe((state) => {
  console.log(state.activity);
  console.log(state.comments_by_entity_id);
  // True if activity is being fetched
  console.log(state.is_loading);
});
// Comment pagination
activityWithStateUpdates.loadNextPageActivityComments;
activityWithStateUpdates.loadNextPageCommentReplies;

// Optionally start watching the feed
// If activity belongs to multiple feeds, it's up to you to choose which feed to watch
const fid = activityWithStateUpdates.currentState.activity!.feeds[0];
const [group, id] = fid.split(':');
const feed = client.feed(group, id);
let shouldWatch = false;
if (!feed.currentState.watch) {
  await feed.getOrCreate({
    watch: true,
    limit: 0,
    followers_pagination: { limit: 0 },
    following_pagination: { limit: 0 },
  });
}

// When leaving the page...
// dispose activity, this avoids refetching the activity if WebSocket reconnects
activityWithStateUpdates.dispose();
// you should stop watching the feed, unless your app has another component that watches the same feed
if (shouldWatch) {
  await feed.stopWatching();
}

// If you don't care about state updates, no need to call activityWithStateUpdates
await client.getActivity({
  id: activityId,
});

Adding activities to multiple feeds

The Stream API allows you to post an activity to multiple feeds, the maximum is 25.

When an activity is posted to multiple feeds, activity.current_feed field is only set when reading a feed (feed.getOrCreate):

  • When reading with current selector, it's set to the feed we're reading
  • For any other selector it'll be one of the feeds the activity is posted to
    • If the user follows one of the feeds, it's set to the followed feed (if more than one feed is followed, it'll be one of the feeds)
  • For all other API calls (for example queryActivities, getActivity) and WebSocket events it's not set
feedsClient := client.Feeds()
response, err := feedsClient.AddActivity(context.Background(), &getstream.AddActivityRequest{
	Type:   "post",
	Feeds:  []string{"user:john", "stock:apple"},
	Text:   getstream.PtrTo("apple stock will go up"),
	UserID: getstream.PtrTo("john"),
})
if err != nil {
	log.Fatal("Error adding activity:", err)
}
log.Printf("Activity added successfully: %+v", response)

Adding activities uses upsert logic. If the activity already exists, it will be updated with the new data.

You do not need to call getOrCreate on a feed before adding an activity to it. If you add an activity to a feed that does not exist yet, the feed is created automatically. This applies to both add activity and add activities (batch) requests.

Previous
Members
Next
Search for Activities