# Generating Twitter Lists with Python and Tweepy
The finished project can be seen here (opens new window)
Paul Graham (opens new window) is an influential man in the tech and startup space.
His Twitter activity keeps me entertained and informed, spanning from discussions about air quality significantly impacting life expectancy (opens new window) to interesting discussions he has with his kids (opens new window).
The air pollution discussion this morning motivated me to want to see his feed and all of the interesting things a man like Paul sees. I started to follow the accounts he follows and after about 30 or so clicks I decided to investigate Twitter's API for a way to automate this.
This is where I discovered Twitter Lists (opens new window).
# Twitter Lists are a great way to create custom feeds
Viewing a List timeline will show you a stream of Tweets from only the accounts on that List.
Twitter Lists are the perfect solution. It gives me the ability to create custom feeds.
If I feel like delving into Paul Grahams feed, it's a click away. Same with Elon Musk or any of the other influential users on Twitter.
# Using Tweepy to automatically generate our Twitter Lists
Tweepy (opens new window) is an easy-to-use Python library for accessing the Twitter API.
Tweepy provides built in methods to easily interact with the Twitter API.
In this project, I use the following from Tweepy:
- API class (opens new window)
- Client class (opens new window)
- .create_list() (opens new window)
- .get_user() (opens new window)
- .get_users_following() (opens new window)
- .add_list_members (opens new window)
# Authenticating with Twitter's API using Tweepy
This tutorial will assume you already have a Twitter developer account. If you do not, I went into detail here (opens new window) on how to generate the proper authentication keys needed to access Twitter's API.
Tweepy provides the helper function
.OAuthHandler that requires you to pass it your consumer key and consumer secret initializing the auth object, you then must call its method
.set_access_token() which requires your access token and access token secret given to you when creating your developer account and generating your app (opens new window).
import tweepy auth = tweepy.OAuthHandler(os.getenv("consumer_key"), os.getenv("consumer_secret")) auth.set_access_token(os.getenv("access_token"), os.getenv("access_token_secret"))
# Initializing Tweepy's API and Client objects
api = tweepy.API(auth) client = tweepy.Client( bearer_token=os.getenv("bearer_token"), consumer_key=os.getenv("consumer_key"), consumer_secret=os.getenv("consumer_secret"), access_token=os.getenv("access_token"), access_token_secret=os.getenv("access_token_secret"), wait_on_rate_limit=True, )
With these objects, we can now access every Twitter endpoint.
# Creating a List using Tweepy's API
Tweepy methods used:
- .create_list() (opens new window): Takes three parameters: name, mode, and description. Name and description are self-explanatory and mode can either be
"private"to define the visibility status of the List.
The response from a successfully List creation returns the List data. I will be using this list later on, so I decided to extract it's id into the variable
list_name = "Paul Grahams's Feed" list_description = "A list of everyone Paul Graham follows" twitter_list = api.create_list(name=list_name, description=list_description) list_id = twitter_list._json["id"]
# Getting a User and the accounts they follow
Tweepy methods used:
client.get_user() a twitter handle - in this case, Paul Graham - I can get all of the public data Twitter provides regarding that user.
I then use that user's data with
client.get_users_following() alongside max_results. The argument
max_results defines how many user objects Twitter will pass back. In this case, I used the max of 1000. The default is 100.
twitter_handle = "paulg" user = client.get_user(username=twitter_handle) followers = client.get_users_following(id=user.data.id, max_results=1000)
# Automatially adding users to the list
Tweepy methods used:
Now that we have the List we want to populate and the followers we want populate it with, we use the
This method takes a list of up to 100 Twitter User ID's. The code snippet below chunks out follower data into sections of 100 Users and generates a list of ids to pass.
We are also passing this method the
list_id that was saved when we created the list.
for i in range(0, len(followers.data), 100): ids = [follower["id"] for follower in followers.data[i : i + 100]] api.add_list_members(list_id=list_id, user_id=ids)
# Things to keep in mind when working with Twitter's API
Twitter rate limits just about all of their endpoints. Here (opens new window) is Twitter's documentation on what the rate limits are. Keep this is mind when developing Twitter-based applications because you may find yourself with an odd error.
Thank you for reading! I hope you enjoyed it.