How to Make a Twitter Bot in Python With Tweepy

Twitter bots can be used for a wide variety of purposes. Creating a bot tailored to your specific needs on this platform is a great way to boost your overall profile statistics.

In this article, you will get to know about the basic procedure to create a Twitter bot in Python using Tweepy.

The Twitter bot that you create following the steps in this article can help you to automate tweets, follow trending accounts, and directly reply to your follower’s queries.

Also, creating this bot and using it for various actions from your Twitter profile is quite easy. Without further ado, let’s get started with making a bot in Python with Tweepy. 

Use Tweepy to Create a Tweet Saying Hello Tweepy

Let’s start with the basics of any programming language – creating a Hello World program. Here’s how you can import the Tweepy library in Python and build your first tweet. Follow the code listed below –

import tweepy

# Authenticate to Twitter

auth = tweepy.OAuthHandler(“CONSUMER_KEY”, “CONSUMER_SECRET”)

auth.set_access_token(“ACCESS_TOKEN”, “ACCESS_TOKEN_SECRET”)

# Create API object

api = tweepy.API(auth)

# Create a tweet

api.update_status(“Hello Tweepy”)

Let’s elaborate a bit on the code written above. Make yourself familiar with the basic syntax and commands used here, as they will be required later. 

1. The first step to creating a Hello Tweepy program is to import the Tweepy package in Python. This can be done simply by using “import tweepy”.
2. In the second command, use your specific consumer key and the secret key to set the authentication credentials of Tweepy. This is essential in order to connect Tweepy to your Twitter profile. 
3. After setting the access tokens, you need to create the API object in python to continue. 
4. Next, you need to use the API object that you just created to call the Twitter API and post your first tweet, “Hello Tweepy”. This is done through the update_status() command. 

In case you don’t know about Twitter authentication keys and the tokens required to create your bot, then we have also discussed them in detail in the later sections. This process of creating a hello world tweet through Tweepy is just a peek at what you can do with this library.

In the further sections, we will first discuss a bit about the Twitter API and the Tweepy library in specific. Even though the bot described in this section is quite simple, once you’re done with this article, you will be able to create complex bots that can help you with a wide variety of functions.

About Twitter API

The Twitter API is essential to provide developers access to some of the endpoints of Twitter that can be used to either read or write information to or from the platform. This is the only way developers can access these features without getting into the low-level programming of Twitter. 

The authentication used by this API is OAuth, and thus every request is authenticated. As clarified in the earlier section, your authentication credentials are quite important to access the Twitter API. Once you have all the details, they can be used to create a multitude of bots that can be used to automate various parts of this platform. 

Another thing to note when using the Twitter API is the fact that there are limits to how many times you can make calls to the API in a specific period. These rate limits have been imposed to mitigate the negative uses of the Twitter API. Make sure that this is a factor that you take into consideration before you start building complex bots. 

Twitter API can also be used to create bots that access Twitter analytics and keep you updated with the latest trending posts from your competitors. In the next section, we will go over the basics of Tweepy and how you can easily get started with it. 

What Is Tweepy?

In case you’re not familiar with Tweepy, it is an open-source Python library that allows you to easily access the Twitter API. This library features many different methods and classes that can be implemented to connect to various Twitter API endpoints. 

Without Tweepy, the process of creating a Twitter bot can be quite complex and time-consuming. This process involves handling low-level functions like HTTP requests, manual authentication, and working around rate limits.

Thankfully, Tweepy makes much of this process accessible to beginners and experienced users alike in the form of a simple and concise Python library. Tweepy allows the user to access almost all of the Twitter API functionalities and you’ll get to know about how you can use this library easily in the next section. 

How to Use Tweepy

Now, let’s start with the steps that you need to follow in order to use Tweepy. The first thing to do is to configure your Twitter account credentials and then make calls to the Twitter API using Tweepy. Before elaborating on the process, let’s go over how to install Tweepy in Python. 

Installation

To install Tweepy, you first need to be familiar with pip, which serves as a python package manager. We will have to build a virtualenv (Virtual Environment) to run the projects discussed in this article. 

Start the process by first creating a project with a name of your choice. For better reference, we have named the project “twitter_bot”. Now, let’s take a look at how you can create a Virtual Environment and create the project directory. Follow the commands listed below:

$ mkdir twitter_bot
$ cd twitter_bot
$ python3 -m venv venv

These commands serve the purpose of creating a virtual environment to run pip inside the specified project directory. Now, you need to install the Tweepy package after activating the virtualenv and using pip to complete the initial setup. Enter and run the lines listed below: 

$ source ./venv/bin/activate
$ pip install tweepy

Once done, you need to make a new file that stores the various dependencies used. We will name this file requirement.txt for convenience. The file can be created directly using this pip command: 

$ pip freeze > requirements.txt

Note that this file is essential when you will be deploying the project in the later sections.                                                                                                                 

Creating Twitter API Authentication Credentials

The second crucial step to create Twitter bots using Tweepy is to create and enter the various authentication credentials that will be used to access the API. Twitter API cannot be accessed without a valid OAuth request, which increases the security of the platform. In this section, we will take a look at the different specific credentials that you require and how to get them. 

The Twitter API credentials are of four different types – 

• Consumer Key
• Consumer Secret
• Access Token
• Access Secret

In case you’ve already signed up for an account on Twitter earlier, then you can just follow the simple steps listed below to get the required credentials. 

1. Create a Twitter Developer Account

One of the most essential steps to creating your bot on Twitter is to make a new developer account, in case you don’t already have one. Visit the Twitter developer portal and apply for a new account, associating the Twitter profile that you want to target along with it. 

Twitter also requests some information regarding what you plan to do with your developer account, and whether this account is intended for personal or commercial purposes.

You can also specify a different name from your main Twitter account when creating a new developer account. 

2. Build the Application

In order to make API calls once you have all the prerequisites, it is essential to create an application. Twitter does not allow accounts to directly access the API, so this step is quite important. 

The first thing in the process of building the application is to visit the Twitter apps page and choose the create an app option. Once done, enter the following details one by one to initialize the app creation process. 

• App Name: This process is as simple as it gets. You just need to enter your desired name for your bot. This name would be private to you and can be used to reference this app later. 
• Application Description: In this part, you need to specify the purpose of the app that you’re creating. You can input a basic summary of your Twitter app. 
• Application’s Website URL: Here, you can either enter your personal website or the site that your Twitter app is connected to. But, as we will be building a bot, you can just enter your personal website details. 
• Use of the app: In this section, you need to specify the use of the app, and provide a brief overview of what it does. Just try to provide a description of what your bot does. 

Once you have filled in all of the details, your application will be ready for further development. 

3. Generate the Authentication Credentials

The next step is to generate the Twitter authentication credentials that will be used to access this platform’s APIs.

• From the homepage of the Twitter developer portal, access the “Apps” page and tap on the “Details” button next to the app that you just created. 
• Now, you should be able to see the options “App details”, “Keys and Tokens”, and “Permissions”. Tap on “Keys and Tokens”
• Select the “Generate” button under the Consumer API keys, Access token, and access token secret keys.
• Once you have the required credentials, save them and keep them handy. These keys and secrets will be used in the next section.

Another great idea before you get started with building the actual bot is to create a simple program using Tweepy that verifies whether the credentials you use are valid or not. In case the output of this program shows “Authentication OK”

Here’s the code: 

import tweepy

#Authenticate to Twitter

auth = tweepy.OAuthHandler(“pGBDoAaEpkliVKBOLwjtcmHGc”, 

    “xF3g1wrP50b6BlZEd20u4oVfjgH1FGQcuWUzlQO5aUWOufvlhw”)

auth.set_access_token(“622518493-6VcLIPprbQbv9wkcBBPvCle8vsjU9fE85Dq9oStl”, 

    “tH9aKQbQQ1iRdYTcLSsPwitl44BkAc6jilrsU0ifnXvZhq”)

api = tweepy.API(auth)

try:

    api.verify_credentials()

    print(“Authentication OK”)

except:

    print(“Error during authentication”)

Review of Tweepy Functionality

In this section, we will take a look at some of the Tweepy functionalities. As you may already know, Tweepy allows developers to access the Twitter API endpoints using python.

One important thing to note when using Tweepy is to know the names used for the different functions like tweets, followers, and likes. 

• Status – This signifies a Tweet on the platform. 
• Friendship – This refers to your followers and the people you follow. 
• Favorite – The likes you receive and the posts you like. 

Now that you’re familiar with the different terminologies used by Tweepy, here are some of the groups these functions are divided into, and their specific use when building a bot. 

• OAuth

Tweepy can easily handle all authentication procedures used by the Twitter API. The “OAuthHandler” class in Tweepy enables you to easily put in your Twitter developer credentials. We have also provided an example code to clarify how Tweepy handles OAuth. 

import tweepy

#Authenticate to Twitter

auth = tweepy.OAuthHandler(“CONSUMER_KEY”, “CONSUMER_SECRET”)

auth.set_access_token(“ACCESS_TOKEN”, “ACCESS_TOKEN_SECRET”)

You need to input your unique keys and secret tokens in the placeholders to continue building the app and getting it to access the Twitter API. 

• API Class

Understanding the API class is perhaps the most important part to start building a functional bot on Twitter. The various methods included with the Tweepy API class allow you to perform a multitude of functions and access the Twitter endpoints. Here’s a simple example of how you can use the API class methods in Tweepy – 

import tweepy

#Authenticate to Twitter

auth = tweepy.OAuthHandler(“CONSUMER_KEY”, “CONSUMER_SECRET”)

auth.set_access_token(“ACCESS_TOKEN”, “ACCESS_TOKEN_SECRET”)

# Create API object

api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)

This code is intended to display the rate limits on accessing the Twitter API. When the rate limit has been exceeded, this program prints a message notifying you about it. Once you create the API object, you can call the various methods offered by it. Here are the API methods offered by Tweepy, so you can reference them later. 

• Accessing and Creating Tweets: This method allows you to read tweets, retweets, and mentions, either on your profile or some other profile on Twitter.
• Accessing the Twitter timeline: These methods cover the creation and modification of new Tweets on the platform. You can directly create Tweets from Python using Tweepy. 
• Methods to get details on Twitter profiles: Using these methods allows you to find the name, description, and location of a specific profile on Twitter, along with a multitude of other methods. 
• Followers and list of people your account follows: You can use these methods to directly follow or unfollow different accounts on the platform. 
• Methods to get details of your account: Using these methods, you can easily change various details of your personal Twitter profile. This can be used to keep your followers updated with new details on your profile automatically. 
• Access to likes on posts: You can either put new likes on the posts in your timeline or specific posts directly from Python. 
• Blocking users: This is a method that helps you to fetch a list of your blocked users, or block/unblock specific users on the platform. 
• Searching throughout the platform: Using the search methods can help you to find specific posts, using a wide variety of keywords. The scope of this search includes the entire Twitter database. 
• Getting trending accounts and posts: This method can be used easily to get a report of the best posts on this platform. You can also specify the regions where you want to see the trending posts from. 
• Methods to stream directly: Through the streaming methods, you can easily look out for tweets and classify them into different categories based on the various filters that you can apply. To use this method, you need to have a stream object and a stream listener. 
• Models, Cursors, and Streams

When using the Twitter API, you need to know about model classes. These are used to perform functions on the data that is received from the Twitter API. These are the different model classes on Tweepy – 

1. User
2. Status
3. Friendship
4. SearchResults

The different methods can be used to manipulate different activities on the platform as discussed earlier. Now, let’s take a look at what cursors are. 

Most of the results returned by the Twitter API only consist of the first page of the query. Cursors can be used to manipulate and work with different parts of the result. First, the cursor object needs to be created. Then the methods can be passed to get the specific section of the paginated results from the Twitter API. 

Additionally, you can also easily refer to the API class documentation in Tweepy to get a list of every single method that can be used. 

How to Make a Twitter Bot in Python With Tweepy

In the earlier sections, we have discussed the basic functions that Tweepy allows you to access. Now, let’s get started with building the actual bot and the process of deploying it to a server through Docker. 

Watching for Twitter Activity

In the context of bots, “Watching” for Twitter activity signifies the constant detection of posts on the platform by the bots. Once the new activity is detected, the bots can directly react to them according to their programming, without any interaction from the user. 

There are a couple of ways in which bots can watch for Twitter activity: 

• Polling: In this method, the bot constantly makes Twitter API calls at regular intervals. After polling, the results are checked for new content. 
• Streams: Here, the bot notifies the user when a new piece of content matching the criteria required is found on Twitter. 

The difference between these two methods is the fact that using streams allows the user to only look for new activities regarding Tweets. While polling can look for content directly in the Twitter API for more thorough results. Also, streaming is more efficient than polling. The use of these methods depends on the context of the bot. 

Presenting the Example Bots

To help you get started with Twitter bots, we have listed some basic examples along with the entire procedure of creating them. Here are the bots discussed in this section: 

1. Follow/Followers Bot – Directly follows the users that follow your profile. 
2. Favorite and Retweet Bot – Likes and Retweets the posts on Twitter that match the user’s parameters.  
3. Reply to Mentions Bot – These bots can reply to the Tweets that contain specific words that are related to support queries.

The Config Module

The config file is another essential part when creating your bots. This file stores the information that is common for all the bot files in the python working directory. This helps with less redundancy in all the bots and adds efficiency. 

This python module will help with common logic for all the bots in the folder named config. The main function of this bot is to authenticate the developer credentials without cluttering the program of the main bot. 

The bots that you create will read the information gathered from Twitter directly from the environment variables. We have included the code for the entire config.txt file here: 

# tweepy-bots/bots/config.py

import tweepy

import logging

import os

logger = logging.getLogger()

def create_api():

    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”)

    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)

    auth.set_access_token(access_token, access_token_secret)

    api = tweepy.API(auth, wait_on_rate_limit=True, 

        wait_on_rate_limit_notify=True)

    try:

        api.verify_credentials()

    except Exception as e:

        logger.error(“Error creating API”, exc_info=True)

        raise e

    logger.info(“API created”)

    return api

Now that you’ve created the config.txt file, let’s continue with the example code of some of the most common bots types. 

The Follow Followers Bot

This code creates a bot that constantly gets the list of the followers on your profile and follows them back automatically. Here’s the source code: 

#!/usr/bin/env python

# tweepy-bots/bots/followfollowers.py

import tweepy

import logging

from config import create_api

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger()

def follow_followers(api):

    logger.info(“Retrieving and following followers”)

    for follower in tweepy.Cursor(api.followers).items():

        if not follower.following:

            logger.info(f”Following {follower.name}”)

            follower.follow()

def main():

    api = create_api()

    while True:

        follow_followers(api)

        logger.info(“Waiting…”)

        time.sleep(60)

if __name__ == “__main__”:

    main()

The Fav & Retweet Bot

Now, let’s take a look at a bot that favorites and retweets any Tweet on the platform that contains the keywords – “Python” and “Tweepy”.

#!/usr/bin/env python

# tweepy-bots/bots/favretweet.py

import tweepy

import logging

from config import create_api

import json

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger()

class FavRetweetListener(tweepy.StreamListener):

    def __init__(self, api):

        self.api = api

        self.me = api.me()

    def on_status(self, tweet):

        logger.info(f”Processing tweet id {tweet.id}”)

        if tweet.in_reply_to_status_id is not None or \

            tweet.user.id == self.me.id:

            # This tweet is a reply or I’m its author so, ignore it

            return

        if not tweet.favorited:

            # Mark it as Liked, since we have not done it yet

            try:

                tweet.favorite()

            except Exception as e:

                logger.error(“Error on fav”, exc_info=True)

        if not tweet.retweeted:

            # Retweet, since we have not retweeted it yet

            try:

                tweet.retweet()

            except Exception as e:

                logger.error(“Error on fav and retweet”, exc_info=True)

    def on_error(self, status):

        logger.error(status)

def main(keywords):

    api = create_api()

    tweets_listener = FavRetweetListener(api)

    stream = tweepy.Stream(api.auth, tweets_listener)

    stream.filter(track=keywords, languages=[“en”])

if __name__ == “__main__”:

    main([“Python”, “Tweepy”])

The Reply to Mentions Bot

Now, we will create a bot that replies with “Reach us via DM” to any queries that include the keywords – “Help” or “Support” from users on the platform to your Tweets. 

#!/usr/bin/env python

# tweepy-bots/bots/autoreply.py

import tweepy

import logging

from config import create_api

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger()

def check_mentions(api, keywords, since_id):

    logger.info(“Retrieving mentions”)

    new_since_id = since_id

    for tweet in tweepy.Cursor(api.mentions_timeline,

        since_id=since_id).items():

        new_since_id = max(tweet.id, new_since_id)

        if tweet.in_reply_to_status_id is not None:

            continue

        if any(keyword in tweet.text.lower() for keyword in keywords):

            logger.info(f”Answering to {tweet.user.name}”)

            if not tweet.user.following:

                tweet.user.follow()

            api.update_status(

                status=”Please reach us via DM”,

                in_reply_to_status_id=tweet.id,

            )

    return new_since_id

def main():

    api = create_api()

    since_id = 1

    while True:

        since_id = check_mentions(api, [“help”, “support”], since_id)

        logger.info(“Waiting…”)

        time.sleep(60)

if __name__ == “__main__”:

    main()

Deploying Bots to a Server Using Docker

Till now, we have run all the bots created using Tweepy on a local machine. For scaling up your bots and switching to production, deploying your bot to Docker is a great idea. Let’s take a look at how you can do this. 

Building the Docker Image

To create a package for your bot, you first need to build a Dockerfile in the top directory of your project. This file is mainly used to store the information related to the docker image that contains your app. Here’s the code for the Dockerfile: 

FROM python:3.7-alpine

COPY bots/config.py /bots/

COPY bots/favretweet.py /bots/

COPY requirements.txt /tmp

RUN pip3 install -r /tmp/requirements.txt

WORKDIR /bots

CMD [“python3”, “favretweet.py”]

Once done, build the Docker image using this code: 

$ docker build. -t fav-retweet-bot

This concludes the process of deploying your bot to a wide variety of platforms using Docker. 

Wrapping Up

Creating a Twitter bot is essential if you want to scale up your profile and get more engagement on this platform. Using Tweepy in Python to create your bots is one of the most simple ways to complete this process.

We hope the steps and the examples listed in this article have helped you to get your Twitter bot running and increase your overall reach on Twitter.