I Built a macOS GUI App to Find Instagram Unfollowers

Introduction

Managing an Instagram following list can become messy over time.

You follow people, some follow you back, some do not, and eventually it becomes difficult to know who is actually mutual. I wanted to build a simple desktop tool that makes this easier without sending user data to an external server.

That is why I built InstaClean, a macOS GUI application that helps users find Instagram accounts that do not follow them back and unfollow selected accounts from a local interface.

The goal was simple:

Build a clean, local, dark-mode desktop app for checking Instagram unfollowers.

What the App Does

InstaClean scans your Instagram following list and compares it with your followers list.

Then it shows the accounts that you follow but that do not follow you back.

The app includes:

• A dark modern interface inspired by Instagram
• A scan button to detect non-followers
• Search functionality
• Pagination for easier navigation
• Multi-select checkboxes
• An “Unfollow Selected” button
• Local execution, meaning data stays on your machine

The idea was to make the workflow fast and simple:

1. Open the app
2. Scan your account
3. Review the results
4. Select accounts
5. Unfollow only the ones you choose

Why I Built It as a Desktop App

I could have built this as a web app, but I wanted the project to stay local.

A desktop app made more sense because:

• users do not need to upload their Instagram data anywhere
• the app can run directly on macOS
• the interface feels more private
• setup is simple for Python users
• the project can be packaged later as a .app

Privacy was one of the main design goals. The app does not need a separate backend server, database, or hosted API.

Everything runs locally.

Tech Stack

The project uses Python and a desktop GUI approach.

The basic stack is:

• Python 3.9+ for the application logic
• macOS as the target platform
• Instagram web session cookies for authenticated requests
• py2app as an optional tool for generating a macOS .app

The project can be run directly with:

python app.py

For users who want a real macOS application bundle, it can also be packaged with:

pip install py2app
python setup.py py2app

The generated app is placed inside the dist/ folder.

Main Features

1. Scan for accounts that do not follow back

The main feature is the scan system.

When the user clicks Scan Now, the app checks the account’s following and followers data, then displays users who are not following back.

This makes the app useful for people who want to clean their following list manually instead of scrolling through Instagram one account at a time.

2. Search bar

When the result list is long, searching becomes important.

The app includes a search bar so users can quickly filter accounts by username.

This makes the interface much easier to use when there are many results.

3. Pagination

Instead of displaying every result at once, the app uses pagination.

Each page shows a limited number of accounts, which keeps the interface cleaner and easier to navigate.

This also improves usability because the user is not overwhelmed by a huge list.

4. Multi-select unfollow

The app allows users to select multiple accounts and then click Unfollow Selected.

This is faster than unfollowing one by one, but it still gives the user control because they choose which accounts to remove.

5. Local-first design

One of the most important decisions was keeping the app local.

The app is designed so user data stays on the machine. There is no external database, no cloud processing, and no separate server.

For a tool that interacts with a personal social media account, this matters a lot.

Installation

The project can be installed by cloning the repository:

git clone https://github.com/ghazy001/InstaClean.git
cd InstaClean

Then install the Python dependencies:

pip install -r requirements.txt

After that, configure the required Instagram session values inside the app.

The app needs:

CSRFTOKEN = "your_csrftoken"
SESSIONID = "your_sessionid"
DS_USER_ID = "your_user_id"

These values come from your own browser session after logging in to Instagram.

Important: these values should be treated like sensitive credentials. Never share them, never commit them to GitHub, and never publish them in screenshots.

A better future improvement would be to move them into a .env file instead of writing them directly in the code.

Running the App

After setup, the app can be started with:

python app.py

Once the GUI opens:

1. Click Scan Now
2. Wait for the app to load accounts that do not follow back
3. Use the search bar if needed
4. Select the accounts you want to unfollow
5. Click Unfollow Selected

The app gives the user a more organized way to review accounts before taking action.

Important Notes

This project uses Instagram’s unofficial web API through the user’s own browser cookies.

Because of that, there are some important limitations:

• The app is not officially approved by Meta
• Instagram may change its internal endpoints
• Too many unfollow actions can trigger temporary restrictions
• Users should avoid aggressive automation
• Cookies must be kept private

This project should be used responsibly and only with your own Instagram account.

What I Learned

Building this app taught me a lot about combining GUI development, local automation, and user-focused design.

1. A simple GUI can make automation safer

Instead of blindly unfollowing accounts from a script, a GUI gives the user control.

The user can review results, search names, select accounts manually, and decide what to do.

That makes the tool more transparent.

2. Pagination improves usability

At first, it may seem easy to show every result in one list.

But if the list is large, the interface becomes messy.

Pagination makes the app cleaner and easier to use.

3. Local apps are still useful

Not every project needs to be a web app.

For personal tools, desktop apps can be a great choice because they are private, direct, and easy to run.

4. Credentials should be handled carefully

Using browser cookies works, but it also creates security responsibility.

A future version should avoid hardcoding cookies and instead use environment variables or a local configuration file ignored by Git.

Possible Improvements

There are several improvements I would like to add in the future:

• Store cookies in a .env file
• Add better error handling for expired sessions
• Add confirmation dialogs before unfollowing
• Add rate limiting to reduce the risk of temporary blocks
• Add a progress bar during scanning
• Add export to CSV
• Improve packaging as a macOS .app
• Add a safer login/session setup flow
• Add light mode and theme customization

These features would make the app more polished and safer to use.

Final Thoughts

InstaClean started as a simple idea: make it easier to see who does not follow you back on Instagram.

But it became a useful exercise in building a local desktop app with Python, designing a clean GUI, handling user interaction, and thinking carefully about privacy.

The most important lesson from this project is that automation tools should not just be powerful. They should also be understandable, controlled, and respectful of user privacy.

For me, this was a fun project that combined Python, GUI development, and real-world social media workflow automation into one practical macOS app.