![Ryan Carmody personal projects](https://ryancarmody-blog.s3.amazonaws.com/My_project_1_3_e5dbc95e5b.png)

Most of the time, I am chipping away at a personal coding project. I love working on these as I get to complete a something from end to end, including the design, development, deployment and maintenance. These projects often need skills that I currently don't have, so I will spend a lot of time reading and learning so I can get the job done.

Here are the most recent personal projects I have worked on.


## Searchle

![searchlee.png](https://ryancarmody-blog.s3.amazonaws.com/searchlee_9a585be21a.png)

**Check it out at:** [searchle.net](https://searchle.net). **Stack:** React.js

Searchle is not just a game, it's a learning experience. By guessing the word, you tap into the collective curiosity of the internet, offering a peek into global consciousness. Join the thousands of daily players and be part of the Searchle community, a space for curious minds looking for a unique, thought-provoking challenge.

## Smug Chicken

![smug-strapi.png](https://ryancarmody-blog.s3.amazonaws.com/smug_strapi_674e27c016.png)

**Check it out at:** [smugchicken.com](https://smugchicken.com). **Stack:** Angular 15, RxJS, Node.js, MongoDB, Heroku, Firebase and Twitter API.

What happens when you blend AI and Wordle? Smug Chicken! 🐔
 
Smug Chicken is an image-based word game where players must guess the two words entered into an AI art generator to create the resulting grid of four images. 

I got the pleasure of working on this game with my long time friend, [Haydn Kenny](https://www.linkedin.com/in/haydn-kenny-media/). This was a refreshing change as I usually work on web development projects by myself. It was great to be able to workshop ideas and create the best possible product.

So I guess the question is now, are you a smug chicken today?

## WhereTaken

![My project-1 (2).png](https://ryancarmody-blog.s3.amazonaws.com/My_project_1_2_fb63c1599e.png)

**Check it out at:** [wheretaken.com](https://wheretaken.com). **Stack:** Angular 14, RxJS, Node.js, MongoDB, Heroku, Firebase and Twitter API.

I am a big fan of the daily games that became popular during COVID times, e.g. Wordle, Worldle, Flagle etc. I decided to build my own called WhereTaken. You have 6 chances to guess what country it is based on a single photograph. 

I used Angular 14 for the frontend with RxJS to create a completely reactive application. The game also keeps track of how many guesses people took to complete the game as well as their first guess. This information is passed to the Node.js backend and stored in a MongoDB database. That data is then used to show the global daily stats when users have completed the game.

I also have a Twitter Bot active for the [WhereTaken twitter account](https://twitter.com/wheretakengame), which is made using the Twitter API. It will automatically tweet yesterday's photo and answer, the stats from yesterday and will retweet a post related to WhereTaken.

The frontend Angular app is hosted on Firebase and the Node.js backend on Heroku. 

## Retro Snake

![Retro snake](https://ryancarmody-blog.s3.amazonaws.com/Screen_Shot_2022_10_23_at_1_03_06_pm_70bdc8e0c9.png)

**Check it out at:** [playretrosnake.com](https://playretrosnake.com). **Stack:** Angular 14, RxJS and Firebase.

I made this game while trying to improve my skills in creating reactive apps with Angular and RxJS. The game has a global state object which all components subscribe to. When a user presses the WASD keys, it will update the global state and change the direction on the next frame of the game. 

This game is hosted on Firebase.

## Odds Pony

![Play retro snake cover image](https://ryancarmody-blog.s3.amazonaws.com/Screen_Shot_2022_10_23_at_1_27_23_pm_2bda994a31.png)

**Check it out at:** [oddspony.com](https://playretrosnake.com). **Stack:** Angular 14, RxJS, NodeJS, MongoDB, reCAPTCHA, Firebase and Heroku.

I built this application when I wanted to work on a project that handled massive amounts of data. This application scans thousands of odds, which come from an API and gives users useful insights.

I have no interest in gambling/betting, but this was a great opportunity for me to work with an external API, process data and present it back in a meaningful way. Users can sign up for an API key from the data provider, and I make a percentage of those sales. It has created a nice monthly passive income for me. 

## Your budget summary

![Your budget summary cover image](https://ryancarmody-blog.s3.amazonaws.com/Screen_Shot_2022_10_23_at_1_34_16_pm_d8f192a321.png)

**Check it out at:** [yourbudgetsummary.com](https://yourbudgetsummary.com). **Stack:** Angular 13.

I made this project a couple of years ago. It is an application that will take in your income and expenses, and display your budget summary in a nice table at the bottom. 

When I built this, I had been working at RAA for a number of months and had started to gain some knowledge in Angular. I wanted to work on a project, end to end to reiterate some of the things I had learnt.




Most of the time, I am chipping away on some personal coding project. Check in here to see what I am currently working on!

![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.

![Automate instagram posts](https://ryancarmody-blog.s3.amazonaws.com/like_and_Retweet_4_32ef1e2eea.png)

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

## 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 a .env file with your Instagram username and password](#step-3-create-a-env-file-with-your-instagram-username-and-password)
- [Step 4: Login to Instagram using instagram-private-api](#step-4-login-to-instagram-using-instagram-private-api)
- [Step 5: Download the image into a buffer, ready for upload](#step-5-download-the-image-into-a-buffer-ready-for-upload)
- [Step 6: Post to Instagram](#step-6-post-to-instagram)
- [Step 7: Create a cron job](#step-7-create-a-cron-job)
- [Step 8: Add express (optional)](#step-8-add-express-optional)

## Step 1: Install Node
I am assuming 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 instagram-private-api
npm install request-promise
npm install dotenv
npm install cron
npm install express
```

## Step 3: Create a `.env` file with your Instagram username and password

Go ahead and create a `.env` file that has your username and password for the account you'd like to post to. We will use these in our application.

```:.env
IG_USERNAME="<your-username>"
IG_PASSWORD="<your-password>"
```

## Step 4: Login to Instagram using `instagram-private-api`

Create a file called `index.js` and require the necessary packages

```js:index.js
require("dotenv").config();
const { IgApiClient } = require('instagram-private-api');
const { get } = require('request-promise');
```

Then, we will create a new async function called `postToInsta`, and add the code to log-in to Instagram

```js:index.js
const postToInsta = async () => {
    const ig = new IgApiClient();
    ig.state.generateDevice(process.env.IG_USERNAME);
    await ig.account.login(process.env.IG_USERNAME, process.env.IG_PASSWORD);
}
```

## Step 5: Download the image into a buffer, ready for upload

We now need to download our image from its source, and store it in a buffer. **Note:** If your image is already on your file system, and not hosted somewhere, you can [follow the code in the official docs](https://github.com/dilame/instagram-private-api/blob/23bf2b451dbc219eae6ed09fbc1a73a872528093/examples/upload-photo.example.ts). The process is very similar.

Go ahead and add the following to your `postToInsta` function

```js:index.js
const postToInsta = async () => {
    ...
    const imageBuffer = await get({
        url: 'https://i.imgur.com/BZBHsauh.jpg',
        encoding: null, 
    });
}
```

## Step 6: Post to Instagram

All we need to do now is to post our image to Instagram

Add the following code to your `postToInsta` function

```js:index.js
const postToInsta = async () => {
    ...
    await ig.publish.photo({
        file: imageBuffer,
        caption: 'Really nice photo from the internet!', // nice caption (optional)
    });
}
```
The `photo` method takes and object with different parameters. In this example, we are adding the file (mandatory) and the caption (optional). There are a number of other parameters we could add, [have a look at this example](https://github.com/dilame/instagram-private-api/blob/23bf2b451dbc219eae6ed09fbc1a73a872528093/examples/upload-photo.example.ts) to see what else you can add.

## Step 7: Create a cron job

Generally, an application like this would post on a regular schedule, for example, every day. 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 cronInsta = new CronJob("30 * * * * *", async () => {
    postToInsta();
});

cronInsta.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();
const { IgApiClient } = require('instagram-private-api');
const { get } = require('request-promise');
const CronJob = require("cron").CronJob;

const postToInsta = async () => {
    const ig = new IgApiClient();
    ig.state.generateDevice(process.env.IG_USERNAME);
    await ig.account.login(process.env.IG_USERNAME, process.env.IG_PASSWORD);

    const imageBuffer = await get({
        url: 'https://i.imgur.com/BZBHsauh.jpg',
        encoding: null, 
    });

    await ig.publish.photo({
        file: imageBuffer,
        caption: 'Really nice photo from the internet!',
    });
}

const cronInsta = new CronJob("30 * * * * *", async () => {
    postToInsta();
});

cronInsta.start();
```

## Step 8: Add express (optional)
If you want to host this application 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();

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

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

const { IgApiClient } = require('instagram-private-api');
const { get } = require('request-promise');
const CronJob = require("cron").CronJob;

const postToInsta = async () => {
    const ig = new IgApiClient();
    ig.state.generateDevice(process.env.IG_USERNAME);
    await ig.account.login(process.env.IG_USERNAME, process.env.IG_PASSWORD);

    const imageBuffer = await get({
        url: 'https://i.imgur.com/BZBHsauh.jpg',
        encoding: null, 
    });

    await ig.publish.photo({
        file: imageBuffer,
        caption: 'Really nice photo from the internet!',
    });
}

const cronInsta = new CronJob("30 5 * * *", async () => {
    postToInsta();
});

cronInsta.start();
```

And that is it, your application to post to Instagram using node.js has been created. All that is left to do now is host your application on your favourite hosting platform.

In this tutorial, I will show you how to automate posting to Instagram in just a few steps

/category/nodejs

Latest articles

My personal projects

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

How to automate Instagram posts with Node.js and instagram-private-api (Instagram bot)