As I sit here scrolling through my Twitter feed for the hundredth time today, witnessing the chaos, I can't help but feel defeated. I used to pride myself on my ability to stay focused and productive, but now I find myself constantly getting sucked into the vortex of infinite scrolling apps. I pick my phone up for a tame task, and there goes an hour before I realize what just happened. I have been defeated and infinite scrolling has won over my free time.

It started with scrolling through my Instagram feed, then moved on to Instagram and Twitter. Now, I find myself scrolling through Reddit and sometimes even LinkedIn, all in pursuit of that next dopamine hit. I've become a slave to the never-ending feeds of these apps, and it's ruining my life.


At first, I didn't think it was a big deal. After all, I was **just** checking in on my friends and family, keeping up with the latest news, and occasionally finding funny memes to share with my friends. But as time went on, I found myself spending more and more time on these apps, to the point where I was neglecting my work, my hobbies, and even my relationships. Sometimes, my screen time would be over 8 hours!


I would sit down to work on an important project, but before I knew, I was scrolling through my feed for hours, completely lost in an unending sea of memes, videos, and posts from people I will never even get to see or know. Falsely telling myself that I am just taking a _"quick"_ break from work to return rejuvenated and energized, but before long, that _"quick"_ break turns into an all-day infinite scrolling session.


These apps took up my valuable mental space even when I wasn't actively scrolling. Be it a meeting or an outing with friends, all I could think about was what I was missing on my feed. I was constantly checking my phone, refreshing my feeds, and missing out on the world around me–the real world. I lost my ability to stay focused and read books for hours and hours at a time. Now, I can't finish ten pages before my brain bugs me to check the phone for a new event to fixate over. Even if I stopped thinking about the apps for a while, my phone asked me to _**be real**_ on an app while acting as an entry to an endless, imaginary world.


I tried to fight it at first. I tried deleting the apps from my phone, but I would just end up re-downloading them a few days (sometimes even hours) later. I tried setting limits for myself, but I would always find a way to justify breaking the rules. I tried using apps to block these sites, but I would just see myself going down rabbit holes on other apps instead. One app blocked would mean the other one got its time.


I think I realize what my problem is. The routine of picking up my phone and scrolling through whatever has been happening worldwide is just too easy. I fall for it a bit more easily than I would like to admit. The muscle memory of trying to open an app is apparent when it's not there, uninstalled, in hopes of curing my Pavlovian response to a notification or my phone buzzing. It is just so easy; the content is right there. Just two taps and you are put in front of an infinite scroll of funny videos–covering intriguing topics, sensational news flashes, idiots worldwide, cats, and much more. Even before I am done watching a video, there's another one ready, waiting for me to give in. Sometimes, they even scroll it for you! Reached the end? No problem! Pull down to refresh and get another Pandora's box of internet content to open. How can you not be enticed by such a system?


The content itself doesn't help, either. It feels like I am part of a passive audience that isn't contributing anything to the content quality. Okay, yes, that human hand was a cake, impressive, but what do I have to do anything with that? Aliens used to visit Earth thousands of years ago? Sure. I feel I gain nothing but lose an hour of my time. I lay on my bed while things happen before me, remembering absolutely no detail of what I had just watched.


The worst part is it's not just me. I see it all around me. There are people like me, constantly on their phones, scrolling through their feeds, and missing out on the world around them. Leisure time is significant to me, and these apps are taking it away. Somehow in the pursuit of staying connected, we have detached ourselves from reality. These apps are designed to keep us hooked. Using algorithms and notifications to keep us coming back for more, these apps constantly feed us new content to keep us scrolling while the best minds of our generation improve their ability to keep us in the loop.


Alright, so what can we do about it? I don't have the answers. If I did, I wouldn't be writing this piece in hopes of connecting to people going through the same. I know I'm not too fond of the dark pattern most apps and services nowadays have adopted. When you visit a website hoping to see a post or two, there will be a popup asking you to download an app enabling the grim descent of people like me into the dark abyss of infinite scrolls. Ironically, these popups are precisely what keeps me in check because I absolutely despise this pattern. No, I will not download an app because you say so, Muskman. I want to browse Twitter in my browser, and your artificial omission of features from the website will not persuade me to download your app. I am grateful for companies that do not follow this restrictive pattern.


Did I open Twitter right after finishing this rant?

Infinite Scrolling Has Defeated Me

## Introduction

As the title says, today we are going to see how I made a simple Twitter bot that likes, retweets, and even replies to other tweets using Twitter APIs and Tweepy. We'll also see how to deploy the bot to a server so that it can run continuously without any monitoring required. Sounds cool right? Let's see how you can do it too.

First of all, what **is** Twitter? For people who might not know, Twitter is a micro-blogging site where its users can post short text messages sometimes also containing media such as photos, videos, and for the past few weeks, audio too. The information on Twitter moves fast, I mean *really fast*; which makes it a good source to get/disseminate information faster than other platforms. I am guessing this is why Twitter has its tag line as--

> Twitter. It's what's happening.

Since Twitter has such a wide reach, it can be a good place to grow your presence quickly. One of the ways to grow quickly on Twitter is to maximize interactions and thus to generally be active. Sure, you can do all the heavy-lifting yourself and painstakingly like, retweet, reply, and follow but can you guess who does tedious and monotonous tasks better than you? Machines. Yup, Twitter bots can make your life easier and it doesn't even take much experience to make one. So let's do that!

## The Twitter API

The [Twitter API](https://developer.twitter.com/en/docs) is a set of tools and endpoints that give you access to the functionalities of Twitter and the ability to (in some sense) play with the data. A developer can use the API to execute most of the actions you can normally take on Twitter, programmatically. You can like, retweet, and delete a tweet. You can also reply to tweets that include a specific hashtag, have a specific phrase, or even those that mention your Twitter handle.

The Twitter API uses [OAuth](https://oauth.net/), a widely used open authorization protocol, to authenticate all the requests. Before making any call to the Twitter API, you need to create and configure your authentication credentials. Twitter also has **rate limits** imposed on its API to prevent spammers from overloading their servers. If all this sounds complicated right now, don't worry we will take a look at all of it later in this article.

Technically, with the number of HTTP endpoints Twitter API exposes, the possibilities are truly endless. Although the logo of Twitter sort of inspires us to fly high with the sky being the limit, we are just going to build a basic bot so let's stay grounded, shall we?

## Getting Started

To make a Twitter bot there are a few requirements--

-   Twitter Developer Account
-   Python 3 Installation
-   Tweepy Installation
-   PythonAnywhere Account
-   Basic understanding of programming

### Step 1: Applying for the Twitter Developer Account

To access the tools and the API by Twitter you obviously need a Twitter account but having just that isn't enough. You will need to apply for being a Twitter Developer by filling out an application [here](https://developer.twitter.com/) and clicking on "Apply". It's fairly simple to apply and generally takes at maximum about a day or two for the application to get approved. In my case though, the application was approved instantly. Once your account is approved, you can access the developer documentation and tools.

### Step 2: Creating a Twitter App

Twitter doesn't allow developers to access their API and database using traditional password/key authentication for all projects. Instead, for every use-case/project, the developer needs to create a new Twitter app. Every app has its own set of authentication keys and that's how your bot (or any other type of implementation) will get itself authenticated so that it can communicate with the API.

To create an app, click on "Developer Portal" and navigate to "Projects & Apps" > "Overview". You'll see the following page:

Now, click on the "+ Create App" button. Twitter allows you to create a maximum of 10 Twitter apps which are more than enough for almost everyone trying to explore the API. Once you click the button, it will ask you to name the app. Name it something unique and continue to land on a page that'll look something like this--

Here you can see three strings, namely:

-   API Key
-   API Key Secret
-   Bearer Token

Note down these strings and save them somewhere secure. It is crucial that you DO NOT share these with anyone other yourself. A person having your keys can perform actions on your behalf. In case you feel that someone might have gotten hold of your API keys, you can always regenerate them on your "App Settings" page. Note that this will require you to update your project with new keys as well.

On the "App Settings" page, you can see information about your app on the "Settings" tab and the set of keys on the "Keys and Tokens" tab. Scroll to the "App Permission" section and change the permission to "Read and Write".

In the "Authentication Settings" section, enable "3-legged OAuth". In the "Callback URLs" and "Website URL" fields type in the link to your website or if you don't have a website you can simply put the link to your GitHub repository. In my case, I entered my website: [mayurbhoi.com](https://mayurbhoi.com/). Click on "Save" and go to the "Keys and Tokens" tab next.

Here, you'll be generating the consumer keys for your app which, along with your API keys, will be used to authenticate your app and thus let you access the Twitter API. In the "Authentication Tokens" section, go to "Access Token and Secret" and click on "Generate". The page will show you your tokens that were generated for you to note down. As is the case with API keys, these tokens are very sensitive and you can always regenerate them if you lose them or happen to accidentally share them with someone else.

Once all this is done, your step of creating a Twitter app is complete! On to the coding part *(finally)*.

### Step 3: Installing Python and Tweepy

Get the latest Python v3 SDK from their [official website](https://www.python.org/) and install it on your machine. To check if your installation is correct run the following command--

```
python3 --version
```

and it should show you the version of Python installed.

After checking your Python installation, you need to install [Tweepy](https://www.tweepy.org/).

> Tweepy is an easy-to-use Python library for accessing the Twitter API

Installing Tweepy is extremely easy because of the Python Package Manager (also known as *pip*) and can be done via the Terminal by typing the following command--

```
pip3 install --user tweepy
```

Usually, the installation succeeds but if it doesn't and you encounter any issues or errors, just run the above command again and it should install just fine.

### Step 4: Code for the bot

Since everything we need to start coding is already installed and set up, we can now open a code editor of our choice (I personally am a very big fan of VS Code but let's not get into that debate). Create a folder and name it something fancy. (disco-octopus?)

The bot we are creating will reply to tweets that mention it and have a particular hashtag (in this case #pat) with a GIF. If the tweet doesn't have the ✨special✨ hashtag, it'll simply like the tweet and not reply with anything. The code is split into three sections so that it is easy to understand as it can be very easy to get lost while following a written coding tutorial.

#### 4.1 --- The Setup

Create a new file named **bot.py**. In the file, start by writing the following statement:

```
import tweepy
```

This will import the Tweepy library for you so that you can use it for the project. After doing that, declare your keys by initializing respective variables as follows:

```
consumer_key = '<REPLACE-WITH-YOUR-OWN>'
consumer_secret = '<REPLACE-WITH-YOUR-OWN>'
consumer_secret = '<REPLACE-WITH-YOUR-OWN>'
access_token = '<REPLACE-WITH-YOUR-OWN>'
access_token_secret = '<REPLACE-WITH-YOUR-OWN>'
```

`consumer_key` and `consumer_secret` are your API keys saved in Step 1 while `access_token` and `access_token_secret` are the access tokens generated in the "Keys and Tokens" section of your Twitter app.

Now, add these three lines which enable your program to take your keys and connect them to the Twitter API.

```
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
```

#### 4.2--- Remembering the Last Tweet Replied To

At a glance, you might be wondering why this section is even necessary. It turns out that it is actually one of the most important things to do while coding a Twitter bot. Think about it this way, if you are a bot replying to tweets using tweet IDs, how will you know what tweet was the last one you replied to? Clearly, you need to store the ID somewhere and reference it when you are ready to reply to new tweets, right? So, how do we implement that?

A very simple way to do this is to maintain a plain text file that holds the tweet ID of the last tweet the bot replied to. Every time the code is executed and a tweet is replied to, the ID will be overwritten with the ID of the tweet our bot just replied to. To do this we write two functions, namely `read_last_seen()` and `store_last_seen()`. The code is explained below for these functions:

```
# This function will open the text file and return the ID of
# This function will open the text file and return the ID of
# the latest tweet the bot has successfully replied to
def read_last_seen(FILE_NAME):
    file_read = open(FILE_NAME, 'r') #open the file in read mode
    last_seen_id = int(file_read.read().strip()) #read the Tweet ID as an integer
    file_read.close() #close file reader
    return last_seen_id #return the result

# Overwrite the previous Tweet ID with latest
def store_last_seen(FILE_NAME, last_seen_id):
    file_write = open(FILE_NAME, 'w') #open the file in write mode
    file_write.write(str(last_seen_id)) #write the ID as a string
    file_write.close() #close file writer
    return #return void
```

For these functions to work, you need to make a file named last.txt in the same directory as your Python file. In your Python file declare a variable for the text file and GIF names as follows:

```
FILE_NAME = 'last.txt'
GIF = 'pat-pat.gif'
```

#### 4.3--- The `reply()` Function

The code for the function, the actual good stuff in the program, is as follows:

```
def reply():
    # The API will only send a response containing tweets with IDs that come after the ID
    # stored in the text file
    tweets = api.mentions_timeline(read_last_seen(FILE_NAME), tweet_mode='extended')
    for tweet in reversed(tweets):
        if '#pat' in tweet.full_text.lower():
            print("Patted!: " + str(tweet.id) + " - " + tweet.full_text.lower())
            api.update_with_media(GIF, "@"+ tweet.user.screen_name + " pat pat" + "\nPS: " + random_appreciation(), in_reply_to_status_id=tweet.id)

        elif '#pat' not in tweet.full_text.lower():
            print("Liked!: " + str(tweet.id) + " - " + tweet.full_text.lower())

        store_last_seen(FILE_NAME, tweet.id)
        api.create_favorite(tweet.id) # Like the tweet with mentions
```

The points to note here are:

-   `api.mentions_timeline()` returns an array of tweets that were tweeted after the one that has its ID stored in the text file.
-   We check the array for the hashtag and if found, we call the `api.update_with_media()` function that takes the media file's path you want to include in the reply and the ID of the tweet you want the bot to reply followed by updating the latest replied ID by calling `store_last_seen()`.
-   If the hashtag isn't found, it simply stores the last seen ID and continues to the next tweet.
-   The original tweet is liked in both the cases using `api.create_favorite()`

We are almost done with the bot! At this point, you can run the file and check if it runs. Call the `reply()` function at the end of the file. Log in to Twitter with a different account and Tweet at the bot with & without the hashtag you chose so that you can test both the cases. The bot should like and reply to the tweet containing the hashtag and just like the tweet that doesn't have the specified hashtag.

But wait, we want our bot to check for the tweets continuously right? Yes. Yes, we do. For this, we can simply wrap `reply()` with `while(True)` and call it a day, right? No. Here's why:

We'll be hosting our code on a server, so we should try minimizing the resources used (space and CPU processing time) as much as possible, and should be our top priority. In addition to this, we also need to take care of the rate limits of the Twitter API as discussed previously as making too many requests continuously will exhaust your quota pretty quickly. To do this, just add a delay in the execution of the function. Import the Python library `time` and add the line `time.sleep(30)`. This will pause the program for 30 seconds, which is a pretty reasonable compromise between performance and limiting resource usage.

Sweet! The coding part is over. Now we can deploy our bot to a server so it can run all the time.

### Step 5: Deploying the bot

In order to deploy your bot, you need to host and execute it on a live server. You have tons of options here like creating a Docker container and deploying it on an AWS EC2 server or using Heroku but for the sake of simplicity, we'll use a website that is built solely to host Python scripts.

Go to [pythonanywhere.com](https://pythonanywhere.com/) and create a free account. You'll see a screen like this one:

-   In the "Files" tab, upload all three files in the root directory.
-   Go to the "Consoles" tab and open a new bash console.
-   Type pip3 install --user tweepy to install Tweepy on your server.
-   Type python3 bot.py to start your bot.

Some points to note here are that our free server allows **100 seconds** of CPU computation time and **512MB** of space for our files. Remember when I said optimizing code for minimum CPU usage is always a good idea?

That's it! Congratulations, you've successfully created and deployed your own Twitter bot!

## Wrapping Up

Note that this was just the tip of the iceberg and there's a heck of a lot more to explore in Twitter API than we have managed to cover today in this article. I suggest you read through the official documentation of Twitter API and Tweepy to come up with more complex and innovative ideas for a Twitter bot because as I said possibilities are endless with the number of tools Twitter provides us.

I made this bot because I was bored one day and also so that I could explore the Twitter API. The tools Twitter provides are extremely powerful in terms of what you can do with them, so take a deep dive and keep learning.

Code to my bot is hosted [here](https://github.com/Mayur57/patbot-twitter).

Making a Twitter Bot Using Tweepy

Hey. Glad you're here.

I'll be using this space to share interesting things I come across on a variety of topics, including computers, science, math, and philosophy. These might sometimes include my own thoughts and opinions on these topics.

Many [tech influencers](https://twitter.com/trashh_dev/status/1604864610347229185) prioritise engagement and growth over sharing deep and meaningful content, but I'm not trying to be a tech influencer and this isn't Twitter.

I can't promise that I'll be regular with my posts, but I can assure you that the content I do share will be useful and of high quality.

I hope you find it valuable.

Thoughts & Findings

misc • 08 Dec 2022 • 6 min read

tech • 18 Apr 2021 • 13 min read

misc • 12 Mar 2021 • 1 min read