DEV Community

Cover image for How to Create Your Own Twitter Bot with Python
MK
MK

Posted on • Originally published at techtales.blog on

How to Create Your Own Twitter Bot with Python

#tutorial #python #twitter #automation

If you have ever thought about creating a twitter botthen you are the right place. We will be creating a twitter bot using Python programming language and if you are in process of learning Python, this will be a fun project to polish your programming skills. In this blog post you create your own twitter bot with Python and automate your repetitive tasks.

Setting up your Environment

The first thing is to access to twitter‘s API and you would need Twitter Development account. Here are the steps to follow.

  • Apply for a Developer account here.
  • Now create a new application in developers portal and keep your API keys and access tokens safe.

Preparing your Python Environment

You have to have python installed on your system. After that you will install Tweepy, a python library to interact with Twitter API. Use pip to install it.

pip install tweepy
Enter fullscreen mode Exit fullscreen mode

Use of Twitter API allows your bot to perform actions like tweeting, retweeting and following users etc.

Building Twitter Bot with Python

Lets get to work now.

Authentication

Lets code, first we have to authenticate with Twitter’s API using Tweepy.

import tweepy

# Replace these with your API keys
consumer_key = 'YOUR_CONSUMER_KEY'
consumer_secret = 'YOUR_CONSUMER_SECRET'
access_token = 'YOUR_ACCESS_TOKEN'
access_token_secret = 'YOUR_ACCESS_TOKEN_SECRET'

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

api = tweepy.API(auth)
Enter fullscreen mode Exit fullscreen mode

Sending Tweets

Now that authentication is taken care of, lets send a tweet

api.update_status("Hello, world! This is my first tweet from my Twitter bot.")
Enter fullscreen mode Exit fullscreen mode

You have just tweeted

Automating Likes and Retweets

We can automate liking or retweet a tweet using tweet’s ID. Here’s how

tweet_id = '1234567890'
api.create_favorite(tweet_id) # Like
api.retweet(tweet_id) # Retweet
Enter fullscreen mode Exit fullscreen mode

Follow/Unfollow Users

You can follow or unfollow users by their usernames.

api.create_friendship('username')
api.destroy_friendship('username')
Enter fullscreen mode Exit fullscreen mode

Enhancements for your Twitter Bot with Python

This can be further improved if you add following enhancements.

Directory Structure

Create a project folder twitter_bot and navigate into it. Here is how it should looks like.

twitter_bot/
│
├── .env # Stores API keys and tokens securely
├── bot.py # Main script for your Twitter bot actions
└── requirements.txt # Python dependencies for your project
Enter fullscreen mode Exit fullscreen mode
  • Create .env file that hosts all your important information like API keys and access tokens.
  • Create requirements.txt, a text file to add dependencies for your project.
  • Create bot.py and this will be your main code file that contains main script.

Here is how you .ENV file looks like

CONSUMER_KEY=your_consumer_key_here
CONSUMER_SECRET=your_consumer_secret_here
ACCESS_TOKEN=your_access_token_here
ACCESS_TOKEN_SECRET=your_access_token_secret_here
Enter fullscreen mode Exit fullscreen mode

and your REQUIREMENTS.TXT looks like this

tweepy==3.10.0
python-dotenv==0.15.0
Enter fullscreen mode Exit fullscreen mode

Now main file BOT.PY can have following code.

import tweepy
from dotenv import load_dotenv
import os

# Load environment variables
load_dotenv()

# Set up your Twitter API credentials
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")

# Authenticate with the Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

api = tweepy.API(auth)

# Function to send a tweet
def tweet(message):
    api.update_status(message)
    print("Tweeted: " + message)

if __name__ == " __main__":
    tweet("Hello, world! This is a tweet from my Twitter bot.")
Enter fullscreen mode Exit fullscreen mode

Now in order to use this, open your terminal and run following command.

pip install -r requirements.txt
Enter fullscreen mode Exit fullscreen mode

This will install all the requirements for the project.

Now you can run your script like this.

python bot.py
Enter fullscreen mode Exit fullscreen mode

Here is updated bot.py with enhanced functions like searching tweets, replying, streaming, direct messages, and automated follow backs.

import tweepy
from dotenv import load_dotenv
import os

# Load environment variables
load_dotenv()

# Twitter API credentials
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")

# Authenticate with the Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

api = tweepy.API(auth)

# Tweet a message
def tweet(message):
    api.update_status(message)
    print("Tweeted: " + message)

# Follow a user
def follow(username):
    api.create_friendship(username)
    print(f"Followed {username}")

# Unfollow a user
def unfollow(username):
    api.destroy_friendship(username)
    print(f"Unfollowed {username}")

# Like a tweet
def like(tweet_id):
    api.create_favorite(tweet_id)
    print(f"Liked tweet {tweet_id}")

# Unlike a tweet
def unlike(tweet_id):
    api.destroy_favorite(tweet_id)
    print(f"Unliked tweet {tweet_id}")

# Retweet
def retweet(tweet_id):
    api.retweet(tweet_id)
    print(f"Retweeted {tweet_id}")

# Search tweets
def search_tweets(query, count=10):
    tweets = api.search(q=query, count=count)
    for tweet in tweets:
        print(f"{tweet.id} - {tweet.text}")

# Reply to a tweet
def reply_to_tweet(tweet_id, message):
    api.update_status(status=message, in_reply_to_status_id=tweet_id, auto_populate_reply_metadata=True)
    print(f"Replied to tweet {tweet_id}")

# Automated follow-back
def auto_follow_back():
    for follower in tweepy.Cursor(api.followers).items():
        if not follower.following:
            follower.follow()
            print(f"Followed back {follower.name}")

# Streaming class
class MyStreamListener(tweepy.StreamListener):
    def on_status(self, status):
        print(status.text)

def start_stream(keywords):
    myStreamListener = MyStreamListener()
    myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener)
    myStream.filter(track=keywords)

# Send direct message
def send_direct_message(user_id, message):
    api.send_direct_message(recipient_id=user_id, text=message)
    print(f"DM sent to {user_id}")

if __name__ == " __main__":
    # Example usage (comment out what you don't need)
    tweet("Hello, Twitter World from my bot!")
    follow("username_here")
    unfollow("username_here")
    like("tweet_id_here")
    unlike("tweet_id_here")
    retweet("tweet_id_here")
    search_tweets("Python")
    reply_to_tweet("tweet_id_here", "Thanks for tweeting!")
    auto_follow_back()
    send_direct_message("user_id_here", "Hello from the bot!")
    # start_stream(["Python", "Tweepy"]) # Uncomment to start streaming
Enter fullscreen mode Exit fullscreen mode

Now here under line #83, you will comment out the feature you are not using that API call. Lets say if you just want to send a tweet, in that case comment out everything below tweet function on line 85.

We can further improve this script by adding the option to accept command line arguments. In this case we wont have to edit the main bot file everything we have to do something. See below for updated file.

import tweepy
from dotenv import load_dotenv
import os

# Load environment variables
load_dotenv()

# Twitter API credentials
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")

# Authenticate with the Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

api = tweepy.API(auth)

# Tweet a message
def tweet(message):
    api.update_status(message)
    print("Tweeted: " + message)

# Follow a user
def follow(username):
    api.create_friendship(username)
    print(f"Followed {username}")

# Unfollow a user
def unfollow(username):
    api.destroy_friendship(username)
    print(f"Unfollowed {username}")

# Like a tweet
def like(tweet_id):
    api.create_favorite(tweet_id)
    print(f"Liked tweet {tweet_id}")

# Unlike a tweet
def unlike(tweet_id):
    api.destroy_favorite(tweet_id)
    print(f"Unliked tweet {tweet_id}")

# Retweet
def retweet(tweet_id):
    api.retweet(tweet_id)
    print(f"Retweeted {tweet_id}")

# Search tweets
def search_tweets(query, count=10):
    tweets = api.search(q=query, count=count)
    for tweet in tweets:
        print(f"{tweet.id} - {tweet.text}")

# Reply to a tweet
def reply_to_tweet(tweet_id, message):
    api.update_status(status=message, in_reply_to_status_id=tweet_id, auto_populate_reply_metadata=True)
    print(f"Replied to tweet {tweet_id}")

# Automated follow-back
def auto_follow_back():
    for follower in tweepy.Cursor(api.followers).items():
        if not follower.following:
            follower.follow()
            print(f"Followed back {follower.name}")

# Streaming class
class MyStreamListener(tweepy.StreamListener):
    def on_status(self, status):
        print(status.text)

def start_stream(keywords):
    myStreamListener = MyStreamListener()
    myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener)
    myStream.filter(track=keywords)

# Send direct message
def send_direct_message(user_id, message):
    api.send_direct_message(recipient_id=user_id, text=message)
    print(f"DM sent to {user_id}")

# Initialize argument parser
parser = argparse.ArgumentParser(description="Twitter Bot - Perform actions on Twitter")
parser.add_argument('--action', help='Action to perform: tweet, follow, unfollow, like, unlike, retweet, search, reply, autofollowback, senddm, stream')
parser.add_argument('--param', nargs='*', help='Additional parameters for the action: message, username, tweet_id, query, user_id, keywords')

args = parser.parse_args()

if __name__ == " __main__":
    if args.action and args.param:
        if args.action == "tweet":
            tweet(" ".join(args.param))
        elif args.action == "follow":
            follow(args.param[0])
        elif args.action == "unfollow":
            unfollow(args.param[0])
        elif args.action == "like":
            like(args.param[0])
        elif args.action == "unlike":
            unlike(args.param[0])
        elif args.action == "retweet":
            retweet(args.param[0])
        elif args.action == "search":
            search_tweets(" ".join(args.param))
        elif args.action == "reply":
            reply_to_tweet(args.param[0], " ".join(args.param[1:]))
        elif args.action == "autofollowback":
            auto_follow_back()
        elif args.action == "senddm":
            send_direct_message(args.param[0], " ".join(args.param[1:]))
        elif args.action == "stream":
            start_stream(args.param)
    else:
        print("Please specify an action and any necessary parameters.")
Enter fullscreen mode Exit fullscreen mode

How to Use

With this modified script, you can now run one function at a time by specifying the action and any required parameters from the command line. Here are some examples:

Easier command line usage for Twitter bot with Python

Now it would be easier to send a tweet or performa any function from your terminal like this.

# Send a tweet
python bot.py --action tweet --param "This is a tweet from the command line.

# Follow someone 
python bot.py --action follow --param username_here

# Like a tweet 
python bot.py --action like --param tweet_id_here

# Search tweets
python bot.py --action search --param "Python programming"

# Reply to a Tweet
python bot.py --action reply --param tweet_id_here "Thanks for the info!"
Enter fullscreen mode Exit fullscreen mode

This approach offers flexibility and makes it easy to integrate your Twitter bot into automated workflows or your own custom scripts.

Conclusion

Creating a Twitter bot with Python is a fun project that introduces you to the world of APIs and automation. Next project for yout try on would be to implement the same functionality using OOP in python.

May your bot be with you.

Check out our other posts related to Python programming here.

The post How to Create Your Own Twitter Bot with Python appeared first on TechTales.

Top comments (0)

Read next

mantisus profile image

12 tips on how to think like a web scraping expert

Max Bohomolov -

mrrishimeena profile image

Node.js: Struggling with Winston Logging?

Rishi Kumar -

leandroveiga profile image

Mastering Unit and Integration Testing for Minimal APIs in .NET 8: Best Practices for High-Quality Code

Leandro Veiga -

vitor_melo212 profile image

Comandos GIT

Vitor Melo -