Activity Feeds v3 is in beta — try it out!

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 final bookmark = await feed.addBookmark(activityId: 'activity_123'); // Adding to an existing folder final bookmarkWithFolder = await feed.addBookmark(  activityId: 'activity_123',  request: const AddBookmarkRequest(folderId: 'folder_456'), ); // Update a bookmark (without a folder initially) - add custom data and move it to a new folder final updatedBookmark = await feed.updateBookmark(  activityId: 'activity_123',  request: const UpdateBookmarkRequest(  custom: {'color': 'blue'},  newFolder: AddFolderRequest(  custom: {'icon': '📁'},  name: 'New folder name',  ),  ), ); // Update a bookmark - move it from one existing folder to another existing folder final movedBookmark = await feed.updateBookmark(  activityId: 'activity_123',  request: const UpdateBookmarkRequest(  folderId: 'folder_456',  newFolderId: 'folder_789',  ), );

// 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>", });

// Adding a bookmark to a new folder _, err = client.Feeds().AddBookmark(context.Background(), activityID, &getstream.AddBookmarkRequest{  UserID: getstream.PtrTo("john"), }) if err != nil {  log.Fatal("Error adding bookmark:", err) }  // Adding to an existing folder _, err = client.Feeds().AddBookmark(context.Background(), activityID, &getstream.AddBookmarkRequest{  FolderID: getstream.PtrTo("folder_456"),  UserID: getstream.PtrTo("john"), }) if err != nil {  log.Fatal("Error adding bookmark to folder:", err) }  // Update a bookmark (without a folder initially) - add custom data and move it to a new folder _, err = client.Feeds().UpdateBookmark(context.Background(), activityID, &getstream.UpdateBookmarkRequest{  FolderID: getstream.PtrTo("old folder id"),  NewFolder: &getstream.AddFolderRequest{  Name: "New folder name",  Custom: map[string]any{  "icon": "📂",  },  },  Custom: map[string]any{  "color": "blue",  },  UserID: getstream.PtrTo("john"), }) if err != nil {  log.Fatal("Error updating bookmark:", err) }  // Update a bookmark - move it from one existing folder to another existing folder _, err = client.Feeds().UpdateBookmark(context.Background(), activityID, &getstream.UpdateBookmarkRequest{  FolderID: getstream.PtrTo("old folder id"),  NewFolderID: getstream.PtrTo("new folder id"),  UserID: getstream.PtrTo("john"), }) if err != nil {  log.Fatal("Error moving bookmark:", err) }

AddBookmarkRequest bookmarkRequest =  AddBookmarkRequest.builder()  .userID(testUserId)  .newFolder(AddFolderRequest.builder().name("test-bookmarks1").build())  .build();  AddBookmarkResponse response =  feeds.addBookmark(activityId, bookmarkRequest).execute().getData();

// Adding a bookmark to a new folder $response = $feedsClient->addBookmark(  'activity_123',  new GeneratedModels\AddBookmarkRequest(  userID: 'user_123',  newFolder: new GeneratedModels\AddFolderRequest(name: 'New folder name')  ) );  // Adding to an existing folder $response = $feedsClient->addBookmark(  'activity_123',  new GeneratedModels\AddBookmarkRequest(  userID: 'user_123',  folderID: 'folder_456'  ) );  // Update a bookmark (without a folder initially) - add custom data and move it to a new folder $response = $feedsClient->updateBookmark(  'activity_123',  new GeneratedModels\UpdateBookmarkRequest(  userID: 'user_123',  custom: (object)['color' => 'blue'],  newFolder: new GeneratedModels\AddFolderRequest(  name: 'New folder name',  custom: (object)['icon' => '📁']  )  ) );  // Update a bookmark - move it from one existing folder to another existing folder $response = $feedsClient->updateBookmark(  'activity_123',  new GeneratedModels\UpdateBookmarkRequest(  userID: 'user_123',  folderID: 'folder_456',  newFolderID: 'folder_789'  ) );

var response = await _feedsV3Client.AddBookmarkAsync(  activityId,  new AddBookmarkRequest  {  UserID = _testUserId,  NewFolder = new AddFolderRequest { Name = "test-bookmarks1" }  } );

response = self.client.feeds.add_bookmark(  activity_id,  user_id=self.test_user_id,  new_folder=AddFolderRequest(name="test-bookmarks1"), )

# Adding a bookmark to a new folder bookmark_request = GetStream::Generated::Models::AddBookmarkRequest.new(  user_id: 'user123',  new_folder: GetStream::Generated::Models::AddFolderRequest.new(  name: 'test-bookmarks1'  ) )  response = client.feeds.add_bookmark(activity_id, bookmark_request)  # Adding to an existing folder bookmark_with_folder_request = GetStream::Generated::Models::AddBookmarkRequest.new(  user_id: 'user123',  folder_id: 'folder_456' )  response = client.feeds.add_bookmark(activity_id, bookmark_with_folder_request)  # Update a bookmark (without a folder initially) - add custom data and move it to a new folder update_request = GetStream::Generated::Models::UpdateBookmarkRequest.new(  user_id: 'user123',  custom: {  color: 'blue'  },  new_folder: GetStream::Generated::Models::AddFolderRequest.new(  name: 'New folder name',  custom: {  icon: '📁'  }  ) )  response = client.feeds.update_bookmark(activity_id, update_request)  # Update a bookmark - move it from one existing folder to another existing folder move_request = GetStream::Generated::Models::UpdateBookmarkRequest.new(  user_id: 'user123',  folder_id: 'folder_456',  new_folder_id: 'folder_789' )  response = client.feeds.update_bookmark(activity_id, move_request)

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 feed.deleteBookmark(activityId: 'activity_123', folderId: 'folder_456'); // When you read a feed we include the bookmark final feedData = await feed.getOrCreate(); print(feed.state.activities[0].ownBookmarks);

// 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);

_, err = client.Feeds().DeleteBookmark(context.Background(), activityID, &getstream.DeleteBookmarkRequest{  FolderID: getstream.PtrTo(folderID),  UserID: getstream.PtrTo("john"), })

UpdateBookmarkRequest updateRequest =  UpdateBookmarkRequest.builder().folderID(folderID).userID(testUserId).build();  UpdateBookmarkResponse response =  feeds.updateBookmark(activityId, updateRequest).execute().getData();

// Removing a bookmark $response = $feedsClient->deleteBookmark(  'activity_123',  'folder_456',  'user_123' );  // When you read a feed we include the bookmark $feedResponse = $feedsClient->getOrCreateFeed('user', 'user_123', new GeneratedModels\GetOrCreateFeedRequest(  userID: 'user_123' )); $activities = $feedResponse->getData()->activities; echo $activities[0]['own_bookmarks']; echo $activities[0]['bookmark_count'];

var response = await _feedsV3Client.UpdateBookmarkAsync(  activityId,  new UpdateBookmarkRequest  {  UserID = _testUserId,  FolderID = folderId // Use existing folder ID, not create new folder  } );

bookmark_data = bookmark_response.data folder_id = bookmark_data.bookmark.folder.id response = self.client.feeds.update_bookmark(  activity_id, folder_id=folder_id, user_id=self.test_user_id )

# Removing a bookmark response = client.feeds.delete_bookmark(activity_id, folder_id, 'user123')  # When you read a feed we include the bookmark feed_response = client.feeds.get_or_create('user', 'user123') puts feed_response.activities[0].own_bookmarks puts feed_response.activities[0].bookmark_count

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 = BookmarksFilterField.activityId.equal("activity_123")  ) ) val activityBookmarks: Result<List<BookmarkData>> = activityBookmarkList.get()  // Query by folder ID val folderBookmarkList = client.bookmarkList(  query = BookmarksQuery(  filter = BookmarksFilterField.folderId.equal("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 query = BookmarksQuery(limit: 5); final bookmarkList = client.bookmarkList(query); final page1 = await bookmarkList.get(); // Get next page final page2 = await bookmarkList.queryMoreBookmarks(limit: 3); // Query by activity ID final activityBookmarkList = client.bookmarkList(  const BookmarksQuery(  filter: Filter.equal(BookmarksFilterField.activityId, 'activity_123'),  ), ); final activityBookmarks = await activityBookmarkList.get(); // Query by folder ID final folderBookmarkList = client.bookmarkList(  const BookmarksQuery(  filter: Filter.equal(BookmarksFilterField.folderId, 'folder_456'),  ), ); final folderBookmarks = await folderBookmarkList.get();

// 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",  }, });

// Query bookmarks firstPage, err := client.Feeds().QueryBookmarks(context.Background(), &getstream.QueryBookmarksRequest{  Filter: map[string]any{  "user_id": "john",  },  Limit: getstream.PtrTo(2), }) if err != nil {  log.Fatal("Error querying bookmarks:", err) }  // Get next page _, err = client.Feeds().QueryBookmarks(context.Background(), &getstream.QueryBookmarksRequest{  Filter: map[string]any{  "user_id": "john",  },  Limit: getstream.PtrTo(2),  Next: firstPage.Data.Next, }) if err != nil {  log.Fatal("Error querying next page bookmarks:", err) }  // Query by activity ID _, err = client.Feeds().QueryBookmarks(context.Background(), &getstream.QueryBookmarksRequest{  Filter: map[string]any{  "user_id": "john",  "activity_id": activityID,  }, }) if err != nil {  log.Fatal("Error querying bookmarks by activity ID:", err) }  // Query by folder ID _, err = client.Feeds().QueryBookmarks(context.Background(), &getstream.QueryBookmarksRequest{  Filter: map[string]any{  "user_id": "john",  "folder_id": folderID,  }, }) if err != nil {  log.Fatal("Error querying bookmarks by folder ID:", err) }

Map<String, Object> filter = new HashMap<>(); filter.put("user_id", testUserId);  QueryBookmarksRequest request =  QueryBookmarksRequest.builder().limit(10).filter(filter).build();  QueryBookmarksResponse response = feeds.queryBookmarks(request).execute().getData();

// Query bookmarks $firstPage = $feedsClient->queryBookmarks(  new GeneratedModels\QueryBookmarksRequest(  limit: 2,  filter: (object)['user_id' => 'user_123']  ) );  // Get next page $secondPage = $feedsClient->queryBookmarks(  new GeneratedModels\QueryBookmarksRequest(  limit: 2,  next: $firstPage->getData()->next,  filter: (object)['user_id' => 'user_123']  ) );  // Query by activity ID $response = $feedsClient->queryBookmarks(  new GeneratedModels\QueryBookmarksRequest(  filter: (object)[  'user_id' => 'user_123',  'activity_id' => 'activity_123'  ]  ) );  // Query by folder ID $response = $feedsClient->queryBookmarks(  new GeneratedModels\QueryBookmarksRequest(  filter: (object)[  'user_id' => 'user_123',  'folder_id' => 'folder_456'  ]  ) );

var response = await _feedsV3Client.QueryBookmarksAsync(  new QueryBookmarksRequest  {  Limit = 10,  Filter = new Dictionary<string, object> { ["user_id"] = _testUserId }  } );

response = self.client.feeds.query_bookmarks(  limit=10, filter={"user_id": self.test_user_id} )

# Query bookmarks query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  limit: 10,  filter: {  user_id: 'user123'  } )  response = client.feeds.query_bookmarks(query_request)  # Query by activity ID activity_query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  filter: {  user_id: 'user123',  activity_id: 'activity_123'  } )  response = client.feeds.query_bookmarks(activity_query_request)  # Query by folder ID folder_query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  filter: {  user_id: 'user123',  folder_id: 'folder_456'  } )  response = client.feeds.query_bookmarks(folder_query_request)

Bookmarks Queryable Built-In Fields

name	type	description	supported operations	example
`user_id`	string or list of strings	The ID of the user who owns the bookmark	`$in`, `$eq`	`{ user_id: { $eq: 'user_123' } }`
`activity_id`	string or list of strings	The ID of the activity that was bookmarked	`$in`, `$eq`	`{ activity_id: { $eq: 'activity_123' } }`
`folder_id`	string or list of strings	The ID of the folder containing the bookmark	`$eq`, `$in`, `$exists`	`{ folder_id: { $exists: true } }`
`created_at`	string, must be formatted as an RFC3339 timestamp	The time the bookmark was created	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`
`updated_at`	string, must be formatted as an RFC3339 timestamp	The time the bookmark was last updated	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ updated_at: { $gte: '2023-12-04T09:30:20.45Z' } }`

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 = BookmarkFoldersFilterField.folderName.contains("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 query = BookmarkFoldersQuery(limit: 5); final bookmarkFolderList = client.bookmarkFolderList(query); final page1 = await bookmarkFolderList.get(); // Get next page final page2 = await bookmarkFolderList.queryMoreBookmarkFolders(limit: 3); // Query by folder name (partial matching) final projectFolderList = client.bookmarkFolderList(  const BookmarkFoldersQuery(  filter: Filter.contains(BookmarkFoldersFilterField.name, 'project'),  ), ); final projectFolders = await projectFolderList.get();

// 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, });

// Query bookmark folders firstPage, err := client.Feeds().QueryBookmarkFolders(context.Background(), &getstream.QueryBookmarkFoldersRequest{  Filter: map[string]any{  "user_id": "<user id>",  },  Limit: getstream.PtrTo(2), }) if err != nil {  log.Fatal("Error querying bookmark folders:", err) } // Get next page _, err = client.Feeds().QueryBookmarkFolders(context.Background(), &getstream.QueryBookmarkFoldersRequest{  Filter: map[string]any{  "user_id": "<user id>",  },  Limit: getstream.PtrTo(2),  Next: firstPage.Data.Next, }) if err != nil {  log.Fatal("Error querying bookmark folders second page:", err) }  // Query with folder name filter _, err = client.Feeds().QueryBookmarkFolders(context.Background(), &getstream.QueryBookmarkFoldersRequest{  Filter: map[string]any{  "user_id": "<user id>",  "folder_name": map[string]any{  "$contains": "project",  },  },  Limit: getstream.PtrTo(2),  Next: firstPage.Data.Next, }) if err != nil {  log.Fatal("Error querying bookmark folders with filter:", err) }

Map<String, Object> filter = new HashMap<>(); filter.put("user_id", testUserId);  QueryBookmarksRequest request =  QueryBookmarksRequest.builder().limit(10).filter(filter).build();  QueryBookmarksResponse response = feeds.queryBookmarks(request).execute().getData();

// Query bookmark folders $firstPage = $feedsClient->queryBookmarkFolders(  new GeneratedModels\QueryBookmarkFoldersRequest(  limit: 2,  filter: (object)['user_id' => 'user_123']  ) );  // Get next page $secondPage = $feedsClient->queryBookmarkFolders(  new GeneratedModels\QueryBookmarkFoldersRequest(  limit: 2,  next: $firstPage->getData()->next,  filter: (object)['user_id' => 'user_123']  ) );  // Query by folder name (partial matching) $response = $feedsClient->queryBookmarkFolders(  new GeneratedModels\QueryBookmarkFoldersRequest(  filter: (object)[  'user_id' => 'user_123',  'folder_name' => [  '$contains' => 'project'  ]  ],  limit: 2  ) );

var response = await _feedsV3Client.QueryBookmarksAsync(  new QueryBookmarksRequest  {  Limit = 10,  Filter = new Dictionary<string, object> { ["user_id"] = _testUserId }  } );

response = self.client.feeds.query_bookmarks(  limit=10, filter={"user_id": self.test_user_id} )

# Query bookmarks query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  limit: 10,  filter: {  user_id: 'user123'  } )  response = client.feeds.query_bookmarks(query_request)  # Query by activity ID activity_query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  filter: {  user_id: 'user123',  activity_id: 'activity_123'  } )  response = client.feeds.query_bookmarks(activity_query_request)  # Query by folder ID folder_query_request = GetStream::Generated::Models::QueryBookmarksRequest.new(  filter: {  user_id: 'user123',  folder_id: 'folder_456'  } )  response = client.feeds.query_bookmarks(folder_query_request)

Bookmark Folders Queryable Built-In Fields

name	type	description	supported operations	example
`user_id`	string or list of strings	The ID of the user who owns the folder	`$in`, `$eq`	`{ user_id: { $eq: 'user_123' } }`
`folder_name`	string or list of strings	The name of the bookmark folder	`$eq`, `$in`, `$contains`	`{ folder_name: { $contains: 'work' } }`
`created_at`	string, must be formatted as an RFC3339 timestamp	The time the folder was created	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`
`updated_at`	string, must be formatted as an RFC3339 timestamp	The time the folder was last updated	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ updated_at: { $gte: '2023-12-04T09:30:20.45Z' } }`

Reactions

Comments