Activity Feeds V3 is in closed alpha — do not use it in production (just yet).

Feed and Activity Visibility

Feed Visibility Levels

Feed groups have a default visibility (if it’s not set when creating the group, visible will be set). You can also override the group’s default when creating a feed. A feed’s visibility level can’t be changed after creation.

// More options
let query = FeedQuery(
    group: "user",
    id: "jack",
    data: .init(
        visibility: "public"
    )
)
let feed = client.feed(for: query)
try await feed.getOrCreate()

// More options
val query = FeedQuery(
    group = "user",
    id = "jack",
    data = FeedInputData(
        visibility = FeedVisibility.Public
    )
)
val feed = client.feed(query = query)
feed.getOrCreate()

const feed = client.feed("user", "jack");
await feed.getOrCreate({
  data: {
    visibility: "public",
  },
});

// More options
const query = FeedQuery(
  fid: FeedId(group: 'user', id: 'jack'),
  data: FeedInputData(
    visibility: FeedVisibility.public,
  ),
);
final feed = client.feedFromQuery(query);
await feed.getOrCreate();

// More options
const feed = client.feeds.feed("user", "jack");
await feed.getOrCreate({
  data: {
    visibility: "public",
  },
  // The owner of the feed
  user_id: "<user id>",
});

const response = await client.feeds.createFeedGroup({
  feed_group_id: "myid",
  default_visibility: "public",
  // Other settings...
});

feed := client.Feeds().Feed("user", "alice")
feed.GetOrCreate(context.Background(), &getstream.GetOrCreateFeedRequest{
  Data: &getstream.FeedInput{
    // Override group's default visibility
    Visibility: getstream.PtrTo("public"),
  },
  UserID: getstream.PtrTo("alice"),
})

feedGroupID := "test-feed-group"
createResponse, err := client.Feeds().CreateFeedGroup(context.Background(), &getstream.CreateFeedGroupRequest{
  ID:                feedGroupID,
  DefaultVisibility: getstream.PtrTo("public"),
  // Other settings
})
if err != nil {
  log.Fatal("Error creating feed group:", err)
}
log.Printf("Feed group created: %+v", createResponse.Data)

$createResponse = $this->feedsV3Client->createFeedGroup(
    new \GetStream\GeneratedModels\CreateFeedGroupRequest(
        id: $feedGroupId,
        defaultVisibility: 'public',
        activityProcessors: [
            ['type' => 'default']
        ]
    )
);

var createResponse = await _feedsV3Client.CreateFeedGroupAsync(new CreateFeedGroupRequest
{
    ID = feedGroupId,
    DefaultVisibility = "public",
    ActivityProcessors = new List<ActivityProcessorConfig>
    {
        new() { Type = "default" }
    }
});

create_response = self.client.feeds.create_feed_group(
    id= feed_group_id,
    default_visibility= "public",
)

Supported visibility levels:

Level	Viewing feed (activities + metadata)	Following	Posting
`visible`	Anyone can view	Anyone can follow	Only the owner or member/follower with the post permission can post
`public`	Anyone can view	Anyone can follow	Anyone can post
`followers`	Only approved followers can view	Anyone can send a follow request, follow requests have to be approved	Only the owner or member/follower with the post permission can post
`members`	Only members can view	Only members can follow	Only the owner or member/follower with the post permission can post
`private`	Only the owner can view	Only the owner can follow	Only the owner can post

Activity Visibility Levels

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

val privateActivity: Result<ActivityData> = feed.addActivity(
    request = FeedAddActivityRequest(
        text = "Premium content",
        type = "post",
        visibility = AddActivityRequest.Visibility.Tag,
        visibilityTag = "premium"
    )
)
// Premium users can see full activity, others a preview

feed.addActivity({
  type: "post",
  text: "Premium content",
  visibility: "tag",
  visibility_tag: "premium",
});
// Premium users can see full activity, others a preview

// Premium users can see full activity, others a preview
final privateActivity = await feed.addActivity(
  request: const FeedAddActivityRequest(
    text: 'Premium content',
    type: 'post',
    visibility: AddActivityRequestVisibility.tag,
    visibilityTag: 'premium',
  ),
);

client.feeds.addActivity({
  feeds: ["user:1"],
  type: "post",
  text: "Premium content",
  visibility: "tag",
  visibility_tag: "premium",
  user_id: "<user id>",
});
// Premium users can see full activity, others a preview

response, err := client.Feeds().AddActivity(context.Background(), &getstream.AddActivityRequest{
    Feeds:         []string{"user:alice"},
    Type:          "post",
    Text:          getstream.PtrTo("Premium content"),
    Visibility:    getstream.PtrTo("tag"),
    VisibilityTag: getstream.PtrTo("premium"),
    UserID:        getstream.PtrTo("alice"),
})
if err != nil {
    log.Fatal("Error adding activity:", err)
}

log.Printf("Activity added successfully: %+v", response)
// Premium users can see full activity, others a preview

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

Feeds

Follows