# 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.

<codetabs>

<codetabs-item value="swift" label="Swift">

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

</codetabs-item>

<codetabs-item value="kotlin" label="Kotlin">

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

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="react" label="React">

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

</codetabs-item>

<codetabs-item value="reactnative" label="React Native">

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

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

</codetabs-item>

<codetabs-item value="nodejs" label="Node">

```js
// 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...
});
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
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)
```

</codetabs-item>

<codetabs-item value="php" label="php">

```php
// Create a feed with custom visibility
$feed = $feedsClient->feed('user', 'jack');
$response = $feed->getOrCreateFeed(
    new \GetStream\GeneratedModels\GetOrCreateFeedRequest(
        userID: 'jack',
        data: new \GetStream\GeneratedModels\FeedInput(
            visibility: 'public'
        )
    )
);

// Create a feed group with default visibility
$createResponse = $feedsClient->createFeedGroup(
    new \GetStream\GeneratedModels\CreateFeedGroupRequest(
        id: 'myid',
        defaultVisibility: 'public',
        activityProcessors: [
            ['type' => 'default']
        ]
    )
);
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

client = GetStreamRuby.manual(
  api_key: 'api_key',
  api_secret: 'api_secret'
)

# Create a feed with custom visibility
feed_response = client.feeds.get_or_create_feed(
  'user',
  'jack',
  GetStream::Generated::Models::GetOrCreateFeedRequest.new(
    user_id: 'jack',
    data: GetStream::Generated::Models::FeedInput.new(
      visibility: 'public'
    )
  )
)

# Create a feed group with default visibility
create_request = GetStream::Generated::Models::CreateFeedGroupRequest.new(
  id: 'myid',
  default_visibility: 'public',
  activity_processors: [
    GetStream::Generated::Models::ActivityProcessorConfig.new(type: 'default')
  ]
)
create_response = client.feeds.create_feed_group(create_request)
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
import io.getstream.services.FeedsImpl;
import io.getstream.services.Feed;
import io.getstream.models.*;

FeedsImpl feedsClient = new FeedsImpl(new StreamHTTPClient("<API key>", "<API secret>"));

// Create a feed with custom visibility
Feed feed = new Feed("user", "jack", feedsClient);
GetOrCreateFeedRequest feedRequest = GetOrCreateFeedRequest.builder()
    .userID("jack")
    .data(FeedInput.builder()
        .visibility("public")
        .build())
    .build();
feed.getOrCreate(feedRequest);

// Create a feed group with default visibility
CreateFeedGroupRequest groupRequest = CreateFeedGroupRequest.builder()
    .id("myid")
    .defaultVisibility("public")
    .activityProcessors(List.of(
        ActivityProcessorConfig.builder().type("default").build()
    ))
    .build();
CreateFeedGroupResponse groupResponse = feedsClient.createFeedGroup(groupRequest).execute().getData();
```

</codetabs-item>

</codetabs>

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, </br> 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

<partial id="activity-feeds/v3-latest/_default/_partials/activity-visibility-levels"></partial>


---

This page was last updated at 2026-03-10T10:48:56.470Z.

For the most recent version of this documentation, visit [https://getstream.io/activity-feeds/docs/react/feed-and-activity-visibility/](https://getstream.io/activity-feeds/docs/react/feed-and-activity-visibility/).