Skip to main content

Overview

Bookmarks allow you to save tweets for later reading. You can organize bookmarks into folders and retrieve them at any time. This is useful for saving important tweets, building reading lists, or organizing content by topic.

BookmarkFolder Class

Represents a bookmark folder for organizing saved tweets.

Attributes

id
str
The unique identifier of the bookmark folder.
name
str
The name of the folder.
media
dict
Icon image data associated with the folder.

Methods

get_tweets()

Retrieves tweets saved in this folder.
tweets = await folder.get_tweets()
cursor
str | None
Pagination cursor for retrieving more tweets.
Returns: Result[Tweet] - A Result object containing bookmarked tweets.

edit()

Renames the bookmark folder.
updated_folder = await folder.edit('New Folder Name')
name
str
required
The new name for the folder.
Returns: BookmarkFolder - The updated folder object.

delete()

Deletes the bookmark folder.
await folder.delete()
Returns: Response - HTTP response from the Twitter API.

add()

Adds a tweet to this folder.
await folder.add('1234567890')
tweet_id
str
required
The ID of the tweet to add to the folder.
Returns: Response - HTTP response from the Twitter API.

Managing Bookmarks

Client.bookmark_tweet()

Bookmark a tweet, optionally adding it to a specific folder.
await client.bookmark_tweet(tweet_id)
await client.bookmark_tweet(tweet_id, folder_id='folder_123')
tweet_id
str
required
The ID of the tweet to bookmark.
folder_id
str | None
The ID of the folder to add the bookmark to. If None, adds to the default bookmarks.
Returns: Response - HTTP response from the Twitter API.

Client.delete_bookmark()

Remove a tweet from your bookmarks.
await client.delete_bookmark('1234567890')
tweet_id
str
required
The ID of the tweet to remove from bookmarks.
Returns: Response - HTTP response from the Twitter API.

Client.get_bookmarks()

Retrieve your bookmarked tweets.
bookmarks = await client.get_bookmarks()
bookmarks = await client.get_bookmarks(count=50, folder_id='folder_123')
count
int
default:"20"
The number of bookmarks to retrieve per request.
cursor
str | None
Pagination cursor for retrieving more bookmarks.
folder_id
str | None
The ID of a specific folder to retrieve bookmarks from. If None, retrieves all bookmarks.
Returns: Result[Tweet] - A Result object containing bookmarked tweets with pagination support.

Client.delete_all_bookmarks()

Delete all your bookmarks at once.
await client.delete_all_bookmarks()
Returns: Response - HTTP response from the Twitter API.
This operation cannot be undone. All your bookmarks will be permanently deleted.

Working with Folders

Client.get_bookmark_folders()

Retrieve all your bookmark folders.
folders = await client.get_bookmark_folders()
cursor
str | None
Pagination cursor for retrieving more folders.
Returns: Result[BookmarkFolder] - A Result object containing bookmark folders.

Client.create_bookmark_folder()

Create a new bookmark folder.
folder = await client.create_bookmark_folder('Python Tutorials')
name
str
required
The name for the new folder.
Returns: BookmarkFolder - The newly created folder object.

Client.edit_bookmark_folder()

Rename an existing bookmark folder.
updated_folder = await client.edit_bookmark_folder('folder_123', 'New Name')
folder_id
str
required
The ID of the folder to rename.
name
str
required
The new name for the folder.
Returns: BookmarkFolder - The updated folder object.

Client.delete_bookmark_folder()

Delete a bookmark folder.
await client.delete_bookmark_folder('folder_123')
folder_id
str
required
The ID of the folder to delete.
Returns: Response - HTTP response from the Twitter API.

Usage Examples

Basic Bookmarking

# Bookmark a single tweet
tweet = await client.get_tweet_by_id('1234567890')
await tweet.bookmark()

# Or use the client method
await client.bookmark_tweet('1234567890')

# Remove a bookmark
await tweet.delete_bookmark()
await client.delete_bookmark('1234567890')

Organizing with Folders

# Create folders for different topics
python_folder = await client.create_bookmark_folder('Python Tips')
ai_folder = await client.create_bookmark_folder('AI Research')

# Bookmark tweets to specific folders
await client.bookmark_tweet('1234567890', folder_id=python_folder.id)
await client.bookmark_tweet('0987654321', folder_id=ai_folder.id)

# Or use the folder method
await python_folder.add('1111111111')

Searching Bookmarks

# Get all bookmarks and search for keywords
bookmarks = await client.get_bookmarks(count=100)

keyword = 'python'
matching_tweets = []

for tweet in bookmarks:
    if keyword.lower() in tweet.text.lower():
        matching_tweets.append(tweet)

print(f"Found {len(matching_tweets)} tweets about '{keyword}'")
for tweet in matching_tweets:
    print(f"- {tweet.text[:100]}...")

Exporting Bookmarks

import json
from datetime import datetime

# Export all bookmarks to JSON
async def export_bookmarks():
    all_bookmarks = []
    bookmarks = await client.get_bookmarks(count=100)
    
    while bookmarks:
        for tweet in bookmarks:
            all_bookmarks.append({
                'id': tweet.id,
                'text': tweet.text,
                'author': tweet.user.screen_name,
                'created_at': tweet.created_at,
                'url': f'https://twitter.com/{tweet.user.screen_name}/status/{tweet.id}'
            })
        
        # Get next page
        if bookmarks.next_cursor:
            bookmarks = await bookmarks.next()
        else:
            break
    
    # Save to file
    filename = f'bookmarks_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json'
    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(all_bookmarks, f, indent=2, ensure_ascii=False)
    
    print(f"Exported {len(all_bookmarks)} bookmarks to {filename}")

await export_bookmarks()
# Automatically bookmark tweets matching criteria
query = 'python tutorial'
tweets = await client.search_tweet(query, 'Latest', count=20)

python_folder = await client.create_bookmark_folder('Python Tutorials')

for tweet in tweets:
    # Check if tweet meets criteria
    if tweet.favorite_count > 100 and not tweet.bookmarked:
        await client.bookmark_tweet(tweet.id, folder_id=python_folder.id)
        print(f"Bookmarked: {tweet.text[:50]}...")

Cleaning Up Bookmarks

from datetime import datetime, timedelta

# Remove bookmarks older than 30 days
bookmarks = await client.get_bookmarks(count=100)
cutoff_date = datetime.now() - timedelta(days=30)

for tweet in bookmarks:
    if tweet.created_at_datetime < cutoff_date:
        await tweet.delete_bookmark()
        print(f"Removed old bookmark: {tweet.id}")

Folder-Based Organization

# Organize bookmarks by topic using hashtags
async def organize_bookmarks_by_hashtag():
    # Create topic folders
    topics = {
        'python': await client.create_bookmark_folder('Python'),
        'javascript': await client.create_bookmark_folder('JavaScript'),
        'ai': await client.create_bookmark_folder('AI/ML')
    }
    
    # Get all bookmarks
    bookmarks = await client.get_bookmarks(count=100)
    
    for tweet in bookmarks:
        # Check hashtags
        for hashtag in tweet.hashtags:
            topic = hashtag.lower()
            if topic in topics:
                # Move to appropriate folder
                await topics[topic].add(tweet.id)
                print(f"Organized tweet {tweet.id} into {topic} folder")
                break

await organize_bookmarks_by_hashtag()

Notes

Bookmarks are private and only visible to you.
The bookmarked attribute on Tweet objects indicates whether you have bookmarked that specific tweet.
When you delete a folder, the bookmarks inside are moved back to your main bookmarks collection.
The delete_all_bookmarks() method permanently removes all bookmarks and cannot be undone.

Build docs developers (and LLMs) love