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

Bookmarks

Overview

The API includes built-in support for bookmarking activities. Here’s a quick example of how to use the bookmark API.

Adding Bookmarks

// Adding a bookmark to a new folder
let bookmark = try await feed.addBookmark(activityId: "activity_123")
// Adding to an existing folder
let bookmarkWithFolder = try await feed.addBookmark(
    activityId: "activity_123",
    request: .init(folderId: "folder_456")
)
// Update a bookmark (without a folder initially) - add custom data and move it to a new folder
let updatedBookmark = try await feed.updateBookmark(
    activityId: "activity_123",
    request: .init(
        custom: ["color": "blue"],
        newFolder: .init(
            custom: ["icon": "📁"],
            name: "New folder name"
        )
    )
)
// Update a bookmark - move it from one existing folder to another existing folder
let movedBookmark = try await feed.updateBookmark(
    activityId: "activity_123",
    request: .init(
        folderId: "folder_456",
        newFolderId: "folder_789"
    )
)

// Adding a bookmark to a new folder
val bookmark: Result<BookmarkData> = feed.addBookmark(activityId = "activity_123")

// Adding to an existing folder
val bookmarkWithFolder: Result<BookmarkData> = feed.addBookmark(
    activityId = "activity_123",
    request = AddBookmarkRequest(folderId = "folder_456")
)

// Update a bookmark (without a folder initially) - add custom data and move it to a new folder
val updatedBookmark: Result<BookmarkData> = feed.updateBookmark(
    activityId = "activity_123",
    request = UpdateBookmarkRequest(
        custom = mapOf("color" to "blue"),
        newFolder = AddFolderRequest(
            custom = mapOf("icon" to "📁"),
            name = "New folder name"
        )
    )
)

// Update a bookmark - move it from one existing folder to another existing folder
val movedBookmark: Result<BookmarkData> = feed.updateBookmark(
    activityId = "activity_123",
    request = UpdateBookmarkRequest(
        folderId = "folder_456",
        newFolderId = "folder_789"
    )
)

// Adding a bookmark to a new folder
const bookmark = await client.addBookmark({
  activity_id: "activity_123",
});

// Adding to an existing folder
const bookmarkWithFolder = await client.addBookmark({
  activity_id: "activity_123",
  folder_id: "folder_456",
});

// Update a bookmark (without a folder initially) - add custom data and move it to a new folder
const updatedBookmark = await client.updateBookmark({
  activity_id: "activity_123",
  folder_id: "<old folder id>",
  new_folder: {
    name: "New folder name",
    custom: {
      icon: "📂",
    },
  },
  custom: {
    color: "blue",
  },
});

// Update a bookmark - move it from one existing folder to another existing folder
const movedBookmark = await client.updateBookmark({
  activity_id: "activity_123",
  folder_id: "<old folder id>",
  new_folder_id: "<new folder id>",
});

// Adding a bookmark to a new folder
const bookmark = await client.feeds.addBookmark({
  activity_id: "activity_123",
  user_id: "<user_id>",
});

// Adding to an existing folder
const bookmarkWithFolder = await client.feeds.addBookmark({
  activity_id: "activity_123",
  folder_id: "folder_456",
  user_id: "<user_id>",
});

// Update a bookmark (without a folder initially) - add custom data and move it to a new folder
const updatedBookmark = await client.feeds.updateBookmark({
  activity_id: "activity_123",
  folder_id: "<old folder id>",
  new_folder: {
    name: "New folder name",
    custom: {
      icon: "📂",
    },
  },
  custom: {
    color: "blue",
  },
  user_id: "<user_id>",
});

// Update a bookmark - move it from one existing folder to another existing folder
const movedBookmark = await client.feeds.updateBookmark({
  activity_id: "activity_123",
  folder_id: "<old folder id>",
  new_folder_id: "<new folder id>",
  user_id: "<user_id>",
});

package main

import (
    "context"
    "log"

    "github.com/GetStream/getstream-go/v3"
)

func main() {
    client, err := getstream.NewClient("<your_api_key>", "<your_api_secret>")
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    feedsClient := client.Feeds()

    // Adding a bookmark to a new folder
    bookmark, err := feedsClient.AddBookmark(ctx, "activity_123", &getstream.AddBookmarkRequest{})
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Bookmark added: %+v", bookmark.Data)

    // Adding to an existing folder
    bookmarkWithFolder, err := feedsClient.AddBookmark(ctx, "activity_123", &getstream.AddBookmarkRequest{
        FolderID: getstream.PtrTo("folder_456"),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Bookmark with folder added: %+v", bookmarkWithFolder.Data)

    // Update a bookmark - add custom data and move it to a new folder
    updatedBookmark, err := feedsClient.UpdateBookmark(ctx, "activity_123", &getstream.UpdateBookmarkRequest{
        Custom: map[string]interface{}{
            "color": "blue",
        },
        NewFolder: &getstream.BookmarkFolderInput{
            Name: getstream.PtrTo("New folder name"),
            Custom: map[string]interface{}{
                "icon": "📁",
            },
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Bookmark updated: %+v", updatedBookmark.Data)

    // Move a bookmark from one existing folder to another existing folder
    movedBookmark, err := feedsClient.MoveBookmark(ctx, "activity_123", &getstream.MoveBookmarkRequest{
        FolderID:    getstream.PtrTo("folder_456"),
        NewFolderID: getstream.PtrTo("folder_789"),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Bookmark moved: %+v", movedBookmark.Data)
}

Removing Bookmarks

// Removing a bookmark
try await feed.deleteBookmark(
    activityId: "activity_123",
    folderId: "folder_456"
)

// When you read a feed we include the bookmark
try await feed.getOrCreate()
print(feed.state.activities[0].ownBookmarks)

// Removing a bookmark
feed.deleteBookmark(
    activityId = "activity_123",
    folderId = "folder_456"
)

// When you read a feed we include the bookmark
feed.getOrCreate()
feed.state.activities.collect { activities ->
    println(activities.first().ownBookmarks)
}

// Removing a bookmark
await client.deleteBookmark({
  activity_id: activityId,
});

// When you read a feed we include the bookmark
const response = await feed.getOrCreate({ watch: true });
console.log(feed.state.getLatestValue().activities?.[0].own_bookmarks);
console.log(feed.state.getLatestValue().activities?.[0].bookmark_count);

// Removing a bookmark
await serverClient.feeds.deleteBookmark({
  activity_id: activityId,
  user_id: testUser2.id,
});

// When you read a feed we include the bookmark
const response = await feed.getOrCreate({ user_id: "sara" });
console.log(results.activities[0].own_bookmarks);
console.log(results.activities[0].bookmark_count);

package main

import (
    "context"
    "log"

    "github.com/GetStream/getstream-go/v3"
)

func main() {
    client, err := getstream.NewClient("<your_api_key>", "<your_api_secret>")
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    feedsClient := client.Feeds()

    // Removing a bookmark
    deleteResponse, err := feedsClient.DeleteBookmark(ctx, "activity_123", &getstream.DeleteBookmarkRequest{
        UserID: getstream.PtrTo("testUser2"),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Bookmark deleted: %+v", deleteResponse)

    // When you read a feed we include the bookmark
    feed := feedsClient.Feed("user", "sara")
    feedResponse, err := feed.GetOrCreate(ctx, &getstream.GetOrCreateFeedRequest{
        UserID: getstream.PtrTo("sara"),
    })
    if err != nil {
        log.Fatal(err)
    }

    if len(feedResponse.Data.Activities) > 0 {
        activity := feedResponse.Data.Activities[0]
        log.Printf("Own bookmarks: %+v", activity.OwnBookmarks)
        log.Printf("Bookmark count: %d", activity.BookmarkCount)
    }
}

Querying Bookmarks

// Query bookmarks
let query = BookmarksQuery(limit: 5)
let bookmarkList = client.bookmarkList(for: query)
let page1 = try await bookmarkList.get()

// Get next page
let page2 = try await bookmarkList.queryMoreBookmarks(limit: 3)

// Query by activity ID
let activityBookmarkList = client.bookmarkList(
    for: .init(
        filter: .equal(.activityId, "activity_123")
    )
)
let activityBookmarks = try await activityBookmarkList.get()

// Query by folder ID
let folderBookmarkList = client.bookmarkList(
    for: .init(
        filter: .equal(.folderId, "folder_456")
    )
)
let folderBookmarks = try await folderBookmarkList.get()

// Query bookmarks
val query = BookmarksQuery(limit = 5)
val bookmarkList = client.bookmarkList(query = query)
val page1: Result<List<BookmarkData>> = bookmarkList.get()

// Get next page
val page2: Result<List<BookmarkData>> = bookmarkList.queryMoreBookmarks(limit = 3)

// Query by activity ID
val activityBookmarkList = client.bookmarkList(
    query = BookmarksQuery(
        filter = Filters.equal("activity_id", "activity_123")
    )
)
val activityBookmarks: Result<List<BookmarkData>> = activityBookmarkList.get()

// Query by folder ID
val folderBookmarkList = client.bookmarkList(
    query = BookmarksQuery(
        filter = Filters.equal("folder_id", "folder_456")
    )
)
val folderBookmarks: Result<List<BookmarkData>> = folderBookmarkList.get()

// Query bookmarks
const firstPage = await client.queryBookmarks({
  limit: 2,
});

// Get next page
const secondPage = await client.queryBookmarks({
  limit: 2,
  next: firstPage.next,
});

// Query by activity ID
const response = await client.queryBookmarks({
  filter: {
    activity_id: "activity_123",
  },
});

// Query by folder ID
const response = await client.queryBookmarks({
  filter: {
    folder_id: "folder_456",
  },
});

// Query bookmarks
const firstPage = await client.feeds.queryBookmarks({
  filter: {
    user_id: "<user id>",
  },
  limit: 2,
});

// Get next page
const secondPage = await client.feeds.queryBookmarks({
  filter: {
    user_id: "<user id>",
  },
  limit: 2,
  next: firstPage.next,
});

// Query by activity ID
const response = await client.feeds.queryBookmarks({
  filter: {
    user_id: "<user id>",
    activity_id: "activity_123",
  },
});

// Query by folder ID
const response = await client.feeds.queryBookmarks({
  filter: {
    user_id: "<user id>",
    folder_id: "folder_456",
  },
});

package main

import (
    "context"
    "log"

    "github.com/GetStream/getstream-go/v3"
)

func main() {
    client, err := getstream.NewClient("<your_api_key>", "<your_api_secret>")
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    feedsClient := client.Feeds()

    // Query bookmarks
    firstPage, err := feedsClient.QueryBookmarks(ctx, &getstream.QueryBookmarksRequest{
        Filter: map[string]interface{}{
            "user_id": "<user id>",
        },
        Limit: getstream.PtrTo(2),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("First page bookmarks: %+v", firstPage.Data.Bookmarks)

    // Get next page
    secondPage, err := feedsClient.QueryBookmarks(ctx, &getstream.QueryBookmarksRequest{
        Filter: map[string]interface{}{
            "user_id": "<user id>",
        },
        Limit: getstream.PtrTo(2),
        Next:  firstPage.Data.Next,
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Second page bookmarks: %+v", secondPage.Data.Bookmarks)

    // Query by activity ID
    activityBookmarks, err := feedsClient.QueryBookmarks(ctx, &getstream.QueryBookmarksRequest{
        Filter: map[string]interface{}{
            "user_id":     "<user id>",
            "activity_id": "activity_123",
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Activity bookmarks: %+v", activityBookmarks.Data.Bookmarks)

    // Query by folder ID
    folderBookmarks, err := feedsClient.QueryBookmarks(ctx, &getstream.QueryBookmarksRequest{
        Filter: map[string]interface{}{
            "user_id":   "<user id>",
            "folder_id": "folder_456",
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Folder bookmarks: %+v", folderBookmarks.Data.Bookmarks)
}

Querying Bookmark Folders

// Query bookmark folders
let query = BookmarkFoldersQuery(limit: 5)
let bookmarkFolderList = client.bookmarkFolderList(for: query)
let page1 = try await bookmarkFolderList.get()

// Get next page
let page2 = try await bookmarkFolderList.queryMoreBookmarkFolders(limit: 3)

// Query by folder name (partial matching)
let projectFolderList = client.bookmarkFolderList(
    for: .init(
        filter: .contains(.folderName, "project")
    )
)
let projectFolders = try await projectFolderList.get()

// Query bookmark folders
val query = BookmarkFoldersQuery(limit = 5)
val bookmarkFolderList = client.bookmarkFolderList(query = query)
val page1: Result<List<BookmarkFolderData>> = bookmarkFolderList.get()

// Get next page
val page2: Result<List<BookmarkFolderData>> = bookmarkFolderList.queryMoreBookmarkFolders(limit = 3)

// Query by folder name (partial matching)
val projectFolderList = client.bookmarkFolderList(
    query = BookmarkFoldersQuery(
        filter = Filters.contains("folder_name", "project")
    )
)
val projectFolders: Result<List<BookmarkFolderData>> = projectFolderList.get()

// Query bookmark folders
const firstPage = await client.queryBookmarkFolders({
  limit: 2,
});

// Get next page
const secondPage = await client.queryBookmarkFolders({
  limit: 2,
  next: firstPage.next,
});

const response = await client.queryBookmarkFolders({
  filter: {
    folder_name: {
      $contains: "project",
    },
  },
  limit: 2,
  next: firstPage.next,
});

// Query bookmark folders
const firstPage = await client.feeds.queryBookmarkFolders({
    filter: {
        user_id: '<user id>'
    },
    limit: 2
});

// Get next page
const secondPage = await client.feeds.queryBookmarkFolders({
    filter: {
        user_id: '<user id>'
    }
    limit: 2,
    next: firstPage.next,
});

const response  = await client.feeds.queryBookmarkFolders({
    filter: {
        user_id: '<user id>',
        folder_name: {
            $contains: 'project'
        }
    },
    limit: 2,
    next: firstPage.next,
});

package main

import (
    "context"
    "log"

    "github.com/GetStream/getstream-go/v3"
)

func main() {
    client, err := getstream.NewClient("<your_api_key>", "<your_api_secret>")
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    feedsClient := client.Feeds()

    // Query bookmark folders
    firstPage, err := feedsClient.QueryBookmarkFolders(ctx, &getstream.QueryBookmarkFoldersRequest{
        Filter: map[string]interface{}{
            "user_id": "<user id>",
        },
        Limit: getstream.PtrTo(2),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("First page folders: %+v", firstPage.Data.BookmarkFolders)

    // Get next page
    secondPage, err := feedsClient.QueryBookmarkFolders(ctx, &getstream.QueryBookmarkFoldersRequest{
        Filter: map[string]interface{}{
            "user_id": "<user id>",
        },
        Limit: getstream.PtrTo(2),
        Next:  firstPage.Data.Next,
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Second page folders: %+v", secondPage.Data.BookmarkFolders)

    // Query by folder name (partial matching)
    projectFolders, err := feedsClient.QueryBookmarkFolders(ctx, &getstream.QueryBookmarkFoldersRequest{
        Filter: map[string]interface{}{
            "user_id": "<user id>",
            "folder_name": map[string]interface{}{
                "$contains": "project",
            },
        },
        Limit: getstream.PtrTo(2),
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Project folders: %+v", projectFolders.Data.BookmarkFolders)
}

Reactions

Comments