Creating a Twitter bot with Node.js

Creating a Twitter bot with Node.js

In this tutorial, we will be learning how to create a simple Twitter bot that automatically tweets a response to a user when they follow the account.

In this tutorial, we will be learning how to create a simple Twitter bot that automatically tweets a response to a user when they follow the account.

We will write the bot in JavaScript using Node.js and it will be awesome!

Table of Contents

  1. Prerequisites
  2. Installing Node and NPM
  3. Initilizing our Project and Installing twit
  4. Creating a new Twitter Application
  5. Starting the Bot
  6. Streams
  7. Listening to Events
  8. Automatically Tweeting with Twit
  9. Running your Twitter Bot
  10. Conclusion
  11. Resources

Here's a look at the finished bot in action:

A look at the Twitter bot we will be building.

Before we dive in, let's ensure you meet the prerequisites for this tutorial.

Prerequisites

  1. Since the bot is written in JavaScript, basic knowledge of JavaScript would be helpful
  2. A Twitter account
  3. A valid phone number that you can verify via SMS

If you have everything you need, let's get the show started.

Installing Node and NPM

To install the npm module we need for our bot, we will first need Node.js, a JavaScript runtime.

  1. Visit the official Node.js website to get the installer.
  2. After it downloads, run the installer until the end.
  3. Restart your computer to ensure the changes can take effect.

The Node.js installer.

The Node.js installer should have also installed NPM for you. To confirm that you have installed both properly, you'll need to open Windows Command Prompt if you're on Windows, or Terminal if you're on Mac or Linux.

To check if you installed node:


    node -v

To check if you installed NPM:


    npm -v

If both of these commands return a version number, you're good to go.

Initilizing our Project and Installing twitter

Create a folder to serve as the home of your bot. Inside that folder, initialize a new project by running this command:


    npm init

Feel free to enter anything you'd like or nothing at all. Once that is complete, you should see a file called package.json. To simplify our interactions with the powerful Twitter API, we will be using an npm module called twit. Twit will serve as our Twitter API client and you can install it by running this command in the same folder as your files:


    npm install twit --save

After that is finished, we are ready to use twit in our code. Let's hop on Twitter!

Creating a new Twitter Application

After you are logged in to your Twitter account, ensure you have a verified phone number tied to the account. Twitter requires this to register any new applications. After your Twitter account has a verified phone number, head on over to the Twitter Application page to start creating a new Twitter application.

The page where you can create a new Twitter application.

Give your application a name, description, website (it can be anything really), check the checkbox, and hit "Create your Twitter Application". Once created, head to your bot from this page and then click on the tab that says "Keys and Access Tokens". On this page you can get the four things you need for your bot:

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

The page where can get your keys and access tokens.

With all the information you need from Twitter on-hand, we can begin coding!

Starting the Bot

Inside the same folder as your package.json, create a file called index.js and let's set up authentication:


    var Twit = require('twit')

    var T = new Twit({
        consumer_key: '',
        consumer_secret: '',
        access_token: '',
        access_token_secret: ''
    })

Import the twit module as the variable Twit and then initialize an instance of it by calling the constructor for it and passing in the credentials you obtained earlier. Let's test and see if Twitter recognizes this information by attempting to authenticate:


    T.get('account/verify_credentials', {
        include_entities: false,
        skip_status: true,
        include_email: false
    }, onAuthenticated)

    function onAuthenticated(err, res) {
        if (err) {
            throw err
        }

        console.log('Authentication successful. Running bot...\r\n')
    }

What this code does is take our twit instance and attempt to authenticate using it. We pass in a callback function to be called after we get a response from Twitter. If Twitter returned an error, we just throw it immediately. If not, and if our credentials are valid, we should see a success message printed.

To start the bot, run this command:


    npm start

If you see:


    Authentication successful. Running bot...

Then the credentials are valid and we can now authorize things like tweets, likes, and retweets.

Streams

We can establish a long-term connection to Twitter's Streaming API by creating a stream using twit. With streams, we can let Twitter do the filtering of events for us, and then only do something when an event that we care about does occur, like, say, a follow of our account.

Creating a stream is simple, and we should do it right after we successfully authenticate:


    function onAuthenticated(err, res) {
        if (err) {
            throw err
        }

        console.log('Authentication successful. Running bot...\r\n')

        var stream = T.stream('user')
    }

That's all you need to create a stream. We're connecting to the user endpoint because the events we care about for this tutorial will only affect us as a user. Here are all the endpoints you could connect to:

  • statuses/filter
  • statuses/sample
  • statuses/firehose
  • user
  • site

They each offer different functionality so definitely read up on the Twitter documentation if you'd like to expand the functionality of your bot.

Listening to Events

For the purposes of this tutorial, the only event we want to listen for is the follow event. Remember that we want to automatically reply to the user thanking them for following our account. Let's attach listeners:


    function onAuthenticated(err, res) {
        if (err) {
            throw err
        }

        console.log('Authentication successful. Running bot...\r\n')

        var stream = T.stream('user')

        stream.on('follow', onFollowed)
        stream.on('error', onError)
    }

After passing in the name of the event you want to listen to, you also pass in a callback function to be called when the event occurs. We also added in a listener on errors so that we can handle them if they occur.

Now let's define those two callback functions:


    function onFollowed(event) {
        var name = event.source.name
        var screenName = event.source.screen_name
        var response = '@' + screenName + ' Thank you for following, ' + name + '!'

        // tweet response to user here

        console.log('I was followed by: ' + name + ' @' + screenName)
    }

    function onError(error) {
        throw error
    }

When a follow event occurs, it fires the onFollowed callback function. Inside it we extract the information that we know we will need which is the user's name and screen name, or Twitter handle. From there we construct our response message which is simply a generic thank you message with their screen name and name embedded in it.

If an error occurs at any point, we simply throw the error immediately. However, you could totally handle this another way if you'd like.

At the end there, we do a simple console.log so that we can see in real-time if we were just followed in the time the bot was running. You could perhaps improve this by adding a timestamp to the log so you also know exactly when you gained a new follower, but that's completely optional!

Now to finish this bot we must tweet a reply to the user that followed.

Automatically Tweeting with Twitter

Tweeting using twit is extremely simple. We just have to call the post method on our twit instance, tell it what we want to post (in this case, a tweet/status), pass in what we want to tweet (our response text), and then finally a callback function.

This looks like this:


    T.post('statuses/update', {
        status: response
    }, onTweeted)

If you're curious where statuses/update comes from, the Twitter docs for it does a great job explaining it! For example, if you wanted to instead send a direct message to a user, you would instead use direct_messages/new.

Now that we have told twit to tweet out our response, we just to need to define the onTweeted callback function and our bot is complete:


    function onTweeted(err, reply) {
        if (err !== undefined) {
            console.log(err)
        } else {
            console.log('Tweeted: ' + reply.text)
        }
    }

If an error occurred, then we log it to our console, otherwise we log the exact thing we tweeted. This is useful if you decide you want to go from a static thank you message to a more dynamic one. By logging what you tweeted, you can ensure your bot is sending the messages you intend for it to send because the response is coming straight from Twitter itself.

Running your Twitter Bot

After you have saved all your files, run this command to start your bot:


    npm start

As like before, if successful you should see:


    Authentication successful. Running bot...

Our Twitter bot in action.

Here is the entire index.js file for our twit-powered Twitter bot:


    var Twit = require('twit')

    var T = new Twit({
        consumer_key: '',
        consumer_secret: '',
        access_token: '',
        access_token_secret: ''
    })

    T.get('account/verify_credentials', {
        include_entities: false,
        skip_status: true,
        include_email: false
    }, onAuthenticated)

    function onAuthenticated(err, res) {
        if (err) {
            throw err
        }

        console.log('Authentication successful. Running bot...\r\n')

        var stream = T.stream('user')

        stream.on('follow', onFollowed)
        stream.on('error', onError)
    }

    function onFollowed(event) {
        var name = event.source.name
        var screenName = event.source.screen_name
        var response = '@' + screenName + ' Thank you for following, ' + name + '!'

        T.post('statuses/update', {
            status: response
        }, onTweeted)

        console.log('I was followed by: ' + name + ' @' + screenName)
    }

    function onError(error) {
        throw error
    }

    function onTweeted(err, reply) {
        if (err !== undefined) {
            console.log(err)
        } else {
            console.log('Tweeted: ' + reply.text)
        }
    }

Conclusion

In this tutorial we have seen how we can use Node.js and the twit npm module to create a simple Twitter bot that automatically responds to users that follow an account. Twit is powerful and can do much more than simply tweet out, including retweeting and liking other tweets. For more information, check out their docs and see how you can take this simple bot and make something more advanced and intricate.

We hope this tutorial has been helpful to you.

node-js javascript

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

How to Hire Node.js Developers And How Much Does It Cost?

A Guide to Hire Node.js Developers who can help you create fast and efficient web applications. Also, know how much does it cost to hire Node.js Developers.

Top 7 Most Popular Node.js Frameworks You Should Know

Node.js is an open-source, cross-platform, runtime environment that allows developers to run JavaScript outside of a browser. In this post, you'll see top 7 of the most popular Node frameworks at this point in time (ranked from high to low by GitHub stars).

Hire Node.JS Developers | Skenix Infotech

We are providing robust Node.JS Development Services with expert Node.js Developers. Get affordable Node.JS Web Development services from Skenix Infotech.

Node.js for Beginners - Learn Node.js from Scratch (Step by Step)

Node.js for Beginners - Learn Node.js from Scratch (Step by Step) - Learn the basics of Node.js. This Node.js tutorial will guide you step by step so that you will learn basics and theory of every part. Learn to use Node.js like a professional. You’ll learn: Basic Of Node, Modules, NPM In Node, Event, Email, Uploading File, Advance Of Node.

Hands on with Node.Js Streams | Examples & Approach

The practical implications of having Streams in Node.js are vast. Nodejs Streams are a great way to handle data chunks and uncomplicate development.