<WatchOnYouTube text="Watch this tutorial on YouTube" link="https://www.youtube.com/watch?v=LCydSB7JcHw" />

Before you create a Twitter bot, you first need to generate all the required keys and tokens. 

## Table of contents
- [Step 1: Head over to the Twitter Developer Platform](#step-1-head-over-to-the-twitter-developer-platform)
- [Step 2: Set up user authentication settings](#step-2-set-up-user-authentication-settings)
- [Step 3: Generate Access Token and Secret](#step-3-generate-access-token-and-secret)

## Step 1: Head over to the Twitter Developer Platform
You will first need a regular Twitter account. Once you have one, you can go to the [Twitter Developer Platform](https://developer.twitter.com/).

Once there, click on the **Developer Portal** button next to your image at the top right hand corner. 

![Developer Portal](https://ryancarmody-blog.s3.amazonaws.com/ASDF_1171fe310a.png)

Twitter may prompt you to have a valid email and/or phone number on your account. It may also ask you why you want to use the Twitter API, you can just enter 'exploring the API'. Enter these in. You should eventually arrive at this page.

![Welcome to the Twitter Developer Platform](https://ryancarmody-blog.s3.amazonaws.com/1_b069f554ac.png)

Enter a name for your application, and click **Get Keys**. You should be shown a page similar to this, with an API key, API key secret, and Bearer Token. Copy them all into a safe place. Then click **Dashboard**.

![API keys and bearer token](https://ryancarmody-blog.s3.amazonaws.com/2_dc2b75db2c.png)

## Step 2: Set up user authentication settings

On the dashboard, click the cog icon under Project App.

![Click the cog icon](https://ryancarmody-blog.s3.amazonaws.com/2something_58ddfb4f5a.png)

Then click on **Set Up**, under User Authentication Settings. 

![User Authentication Settings](https://ryancarmody-blog.s3.amazonaws.com/2_91_10e8ea14e5.png)

This will take you to a page where we can change a number of settings. Under App permissions, we will select **Read and Write**, under Type of App we will select **Web App, Automated App or Bot**. 

![Set read and write and type of app](https://ryancarmody-blog.s3.amazonaws.com/2_93_924b698e28.png)

Under the callback URI, enter **http://192.168.1.101:3000**, which is essentially http://localhost:3000, and finally, enter your/any website URL. Then click **Save**.

![Enter callback url and website](https://ryancarmody-blog.s3.amazonaws.com/2_94_17b91b01e7.png)

## Step 3: Generate Access Token and Secret

Click on the **Keys and tokens** tab.

![Keys and tokens](https://ryancarmody-blog.s3.amazonaws.com/ag_1e5bb0fc06.png)

Once there, click on the **Generate** button for Access Token and Secret. In the image below, it says **Regenerate**, this is because I had previously generated keys. 

![Generate access token and secret](https://ryancarmody-blog.s3.amazonaws.com/3_c8539168f4.png)

This will generate your Access Token and Access Token Secret. Save these in a safe place. 

Once you have done this, the message below the Access Token and Secret should say **Created with Read and Write permissions**. If it doesn't, this means that you did not click **Read and Write** in step 2.

![Read and write access](https://ryancarmody-blog.s3.amazonaws.com/2_97_a88008a4b9.png)

Now you should be done! You should have a **API Key, API Key Secret, Bearer Token, Access Token** and **Access Token Secret**. 

You would have also generated a **Client ID** and **Client Secret**. You will not need these for the following tutorials on creating twitter bots.


In this article, I will show you how to get set up with all the keys and tokens in the Twitter Developer platform. 

![Elon Musk - Make a Twitter Bot](https://ryancarmody-blog.s3.amazonaws.com/build_a_twitter_bot_2_2fe0895d0b.png)

<WatchOnYouTube text="Watch this tutorial on YouTube" link="https://www.youtube.com/watch?v=LCydSB7JcHw" />

Before we start, make sure you are set up with all API keys and tokens from the [Twitter Developer Platform](https://developer.twitter.com/). If you are not, I have a tutorial on [how to generate your keys and tokens for the Twitter API](https://www.ryancarmody.dev/blog/generate-twitter-api-keys-and-tokens).

## Table of contents
- [Step 1: Install Node](#step-1-install-node)
- [Step 2: Create a new node app and install dependencies](#step-2-create-a-new-node-app-and-install-dependencies)
- [Step 3: Create an .env file and load in your API keys](#step-3-create-an-env-file-and-load-in-your-api-keys)
- [Step 4: Create a Twitter client](#step-4-create-a-twitter-client)
- [Step 5: Create an index.js file and call the Twitter API](#step-5-create-an-indexjs-file-and-call-the-twitter-api)
- [Step 6: Create a cron job](#step-6-create-a-cron-job)
- [Step 7: Add express (optional)](#step-7-add-express-optional)

## Step 1: Install Node
I am assuming that if you are at the level of making Twitter Bots, you have Node installed. If not, you will need to [install](https://nodejs.org/en/download/) it.

If you are not sure if you have Node installed, simply run

```bash
node -v
```
It should say something like

```bash
v16.14.2
```

## Step 2: Create a new node app and install dependencies
Let's go ahead a create a new Node.js app with

```bash
npm init -y
```
This will create our `package.json` file for us. We will now add all the packages we will need for our bot.

```bash
npm install twitter-api-v2
npm install dotenv
npm install cron
npm install express
```

## Step 3: Create an `.env` file and load in your API keys

Create a file called `.env`. This is where the API keys and tokens we generate will go. 

Here is an example of a `.env` file. Replace the values with your values you created on the Twitter developer platform.

```bash:.env
NODE_ENV="development"
API_KEY="<your-API-key>"
API_SECRET="<your-API-secret>"
ACCESS_TOKEN="<your-access-token>"
ACCESS_SECRET="<your-access-secret>"
BEARER_TOKEN="<your-bearer-token>"

APP_ID="<your-app-id>"
```

Your `APP_ID` is just the first section of the `ACCESS_TOKEN`. 
E.g. If your `ACCESS_TOKEN` is 
```bash
1587638141888131111-ZbcwdlkfDZjfsdfasdfdff32HJBSdjd
```
then your `APP_ID` is the section before the dash 
```bash
1587638141888131111
```

## Step 4: Create a Twitter client

Using the `twitter-api-v2` package we installed in step 2, we will create a client. Create a new file called `twitterClient.js` and enter the following code.

```js:twitterClient.js
const { TwitterApi } = require("twitter-api-v2");

const client = new TwitterApi({
  appKey: process.env.API_KEY,
  appSecret: process.env.API_SECRET,
  accessToken: process.env.ACCESS_TOKEN,
  accessSecret: process.env.ACCESS_SECRET,
});

const bearer = new TwitterApi(process.env.BEARER_TOKEN);

const twitterClient = client.readWrite;
const twitterBearer = bearer.readOnly;

module.exports = { twitterClient, twitterBearer };
```

We will use the `twitterBearer` to read tweets, and the `twitterClient` to write to the platform e.g. likes, posts etc.

## Step 5: Create an `index.js` file and call the Twitter API

Let's go ahead and create an `index.js` file. This is where we will run our app from. Add the following code

```js:index.js
require("dotenv").config({ path: __dirname + "/.env" });
const { twitterClient } = require("./twitterClient.js")

const tweet = async () => {
  try {
    await twitterClient.v2.tweet("Hello world!");
  } catch (e) {
    console.log(e)
  }
}

tweet();
```

The above code will import the `twitterClient` and tweet out "Hello world!". You can now go to Twitter and check whether the tweet was actually sent.

Here is my twitter just after I ran the above code.

![Twitter after an automated tweet](https://ryancarmody-blog.s3.amazonaws.com/My_project_1_7_c3a5a4a9aa.png)

## Step 6: Create a cron job

Generally, a Twitter bot will tweet out certain information on a regular schedule, for example, every week. We can build on what we already have and add a cron job to our application. To do this, add the following line of code to the top of the `index.js` file.

```js:index.js
const CronJob = require("cron").CronJob;
```

To create a cron job, we add the following

```js:index.js
const cronTweet = new CronJob("30 * * * * *", async () => {
  tweet();
});

cronTweet.start();
```

What does this code do? It creates a cron job that will run when seconds are at 30, not every 30 seconds. I won't go into detail about what the 30 and stars mean, but have a look at [this page which goes through what that syntax does](https://www.netiq.com/documentation/cloud-manager-2-5/ncm-reference/data/bexyssf.html). Similarly, there is this [very handy online tool](https://crontab.guru/) where you can build and edit cron syntax and it will tell you exactly when it will run.

Your final code for this section should look like
```js:index.js
require("dotenv").config({ path: __dirname + "/.env" });
const { twitterClient } = require("./twitterClient.js")
const CronJob = require("cron").CronJob;

const tweet = async () => {
  try {
    await twitterClient.v2.tweet("Hello world!");
  } catch (e) {
    console.log(e)
  }
}

const cronTweet = new CronJob("30 * * * * *", async () => {
  tweet();
});

cronTweet.start();
```

## Step 7: Add express (optional)
If you want to host this Twitter bot on a hosting platform like [heroku](https://heroku.com/), you will need to add express to your node.js app. This is because when hosting node.js applications, they need a port to attach to. 

To do that, simply add the following to your `index.js` file.

```js:index.js
const express = require('express')
const app = express()
const port = process.env.PORT || 4000;

app.listen(port, () => {
  console.log(`Listening on port ${port}`)
})
```

Your final `index.js file should look like this
```js:index.js
require("dotenv").config({ path: __dirname + "/.env" });
const express = require('express')
const app = express()
const port = process.env.PORT || 4000;
const { twitterClient } = require("./twitterClient.js")
const CronJob = require("cron").CronJob;

app.listen(port, () => {
  console.log(`Listening on port ${port}`)
})

const tweet = async () => {
  try {
    await twitterClient.v2.tweet("Hello world!");
  } catch (e) {
    console.log(e)
  }
}

const cronTweet = new CronJob("30 * * * * *", async () => {
  tweet();
});

cronTweet.start();
```

And that is it, your Twitter bot has been created. All that is left to do now is host your application on your favourite hosting platform.


In this tutorial, I will should you how to create a simple Twitter bot in Node.js using the Twitter v2 API.

![Tweet images using v2 API](https://ryancarmody-blog.s3.amazonaws.com/build_a_twitter_bot_3_f9592d8a8d.png)

<WatchOnYouTube text="Watch this tutorial on YouTube" link="https://www.youtube.com/watch?v=6ecUeGy5Td4" />

In this tutorial, I will show you how to tweet out an image using the v2 Twitter API.

This tutorial follows on from [Creating a Twitter bot with Node.js and Twitter API](https://www.ryancarmody.dev/blog/creating-a-twitter-bot-with-nodejs-api), I recommend going through that first to get set up sending a simple tweet.

## Table of contents
- [Step 1: Install required packages](#step-1-install-required-packages)
- [Step 2: Create a utilities.js file and add the download() function](#step-2-create-a-utilitiesjs-file-and-add-the-download-function)
- [Step 3: Upload the image to Twitter and tweet it](#step-3-upload-the-image-to-twitter-and-tweet-it)

## Step 1: Install required packages
We will need a couple more packages for tweeting images. Go ahead and run the following
```bash
npm install fs
npm install request
```
The first package is so we can interact with the file system and the second in for making requests.

## Step 2: Create a `utilities.js` file and add the `download()` function

When we want to tweet an image, we first have to upload the image to the Twitter servers. When we do that, it will return a `mediaId`, which we can then use when creating a tweet with an image. 

If the images you will be tweeting are in the same file system, then you can skip the following. If they are hosted on a third party platform e.g. [Imgur](https://imgur.com/), then you will need to first download it, upload it to the Twitter servers, then use the `mediaId` it sends back to tweet the image. 

Follow the steps below to download the image onto the file system.

Go ahead and create a `utilities.js` and paste the following code

```js:utilities.js
const request = require("request");
const fs = require("fs");

const download = function (uri, filename, callback) {
  request.head(uri, function (err, res, body) {
    request(uri).pipe(fs.createWriteStream(filename)).on("close", callback);
  });
};

module.exports = { download };
```

## Step 3: Upload the image to Twitter and tweet it

Let's go ahead and call the `download` function so we can download the image on the local file system, then upload the image to Twitter, and finally tweet out the image.

In this example, I have an image of Ukraine hosted on Imgur I am using. 

Add the following to your `index.js` file

```js:index.js
const { download } = require("./utilities");

const tweet = async () => {

    const uri = "https://i.imgur.com/Zl2GLjnh.jpg";
    const filename = "image.png";

    download(uri, filename, async function(){
        try {
            const mediaId = await twitterClient.v1.uploadMedia("./image.png");
            await twitterClient.v2.tweet({
                text: "Hello world! This is an image in Ukraine!",
                media: {
                    media_ids: [mediaId]
                }
            });
        } catch (e) {
            console.log(e)
        }
    });
}
```

Your final `index.js` file will look like this

```js:index.js
require("dotenv").config({ path: __dirname + "/.env" });
const { twitterClient } = require("./twitterClient.js");
const CronJob = require("cron").CronJob;
const express = require('express')
const app = express()
const port = process.env.PORT || 4000;
const { download } = require("./utilities");

app.listen(port, () => {
  console.log(`Listening on port ${port}`)
})

const tweet = async () => {

    const uri = "https://i.imgur.com/Zl2GLjnh.jpg";
    const filename = "image.png";

    download(uri, filename, async function(){
        try {
            const mediaId = await twitterClient.v1.uploadMedia("./image.png");
            await twitterClient.v2.tweet({
                text: "Hello world! This is an image in Ukraine!",
                media: {
                    media_ids: [mediaId]
                }
            });
        } catch (e) {
            console.log(e)
        }
    });
}

const cronTweet = new CronJob("*/30 * * * * *", async () => {
    tweet();
});
  
cronTweet.start();
```

You can now go ahead an run the node.js application and it will tweet out your message plus your image.

In this blog post, I will show you how to tweet out images using the v2 twitter API.

![Elon musk thumbs up](https://ryancarmody-blog.s3.amazonaws.com/like_and_Retweet_1_07aa875dd2.png)

<WatchOnYouTube text="Watch this tutorial on YouTube" link="https://www.youtube.com/watch?v=SVt8eTdVbsw" />

In this final Twitter API tutorial, I will show you how to like and retweet using the Twitter API.

## Table of contents
- [Further look at the documentation](#further-look-at-the-documentation)
- [Step 1: Search for tweets](#step-1-search-for-tweets)
- [Step 2: Like tweets](#step-2-like-tweets)
- [Step 3: Retweet a tweet](#step-3-retweet-a-tweet)

## Further look at the documentation

After this final tutorial, you should be able to do everything you want using the API. Have a look at the [documentation here](https://github.com/plhery/node-twitter-api-v2/blob/HEAD/doc/v2.md) and you can search for what you want to do.

For example, if we wanted to delete a tweet, we could go to this section of the docs and follow the instructions

![Delete a tweet](https://ryancarmody-blog.s3.amazonaws.com/My_project_1_2_e74300b925.png)

## Step 1: Search for tweets

Searching for tweets is easy. For this step, we will use the `twitterBearer` we created in [the previous blog post](https://www.ryancarmody.dev/blog/creating-a-twitter-bot-with-nodejs-api).

We can then add the following to our `index.js` file.

```js:index.js
const whereTakenTweets = await twitterBearer.v2.search('#WhereTaken There were');

for await (const tweet of whereTakenTweets) {
    console.log(tweet);
}
```

In my console, it has found the latest 10 tweets that match this criteria, and it has sent back the contents of the tweet under `text` and the `id`. Don't worry about the `edit_history_tweet_ids`, that is not needed.

![Where taken tweet history](https://ryancarmody-blog.s3.amazonaws.com/My_project_1_3_e2f4d0cd93.png)

Now we have the tweets, we can start liking and retweeting them!

## Step 2: Like tweets

To like a tweet, it is very simple, we need to call the following

```js
await client.v2.like('<APP_ID>', '<TWEET_ID>');
```
The `APP_ID` should be an environment variable, as we created this in the previous tutorial. The `TWEET_ID` is the id that was sent back in step 1.

If we wanted to like all of the tweets we found we could do

```js:index.js
const like = async () => {
    const whereTakenTweets = await twitterBearer.v2.search('#Worldle');

    for await (const tweet of whereTakenTweets) {
        await twitterClient.v2.like(process.env.APP_ID, tweet.id);
    }
}
```

## Step 3: Retweet a tweet

Retweeting is very similar to liking. All we need to do is call the `retweet` method.

If we wanted to retweet the first tweet we found while searching, we could do this

```js:index.js
const retweet = async () => {
    const whereTakenTweets = await twitterBearer.v2.search('#WhereTaken There were');

    const tweetID = whereTakenTweets.data.data[0].id;
    await twitterClient.v2.retweet(process.env.APP_ID, tweetID);
}
```

And there you have it. You should now be in a position where you can make whatever Twitter bot you like using these tutorials and the documentation.

This will be the last tutorial on how to create Twitter bots using the v2 Twitter API. I'll show you how to like and retweet tweets.

/category/twitter

Latest articles

Generate your keys and tokens for the Twitter API

Creating a Twitter bot with Node.js and Twitter API

How to tweet images using the v2 Twitter API

How to like and retweet using the Twitter v2 API