GitHub Instagram Analytics: Scripts to Parse Your JSON Data

The Core Challenge: Making Sense of Instagram's JSON Data Structure

Before diving into scripts, you need to understand what you're up against. When you request your data from Instagram, you get a ZIP file containing numerous folders and JSON files. For follower analysis, two files are pivotal: followers_1.json and following.json. Simple enough.

The complexity lies within the data structure itself. Each file typically contains a list of objects, where each object holds user information. It often looks something like this:

[{
  "title": "",
  "media_list_data": [],
  "string_list_data": [
    {
      "href": "https://www.instagram.com/exampleuser",
      "value": "exampleuser",
      "timestamp": 1672531200
    }
  ]
}]

The challenge isn't just reading the file; it's extracting the specific `value` (the username) from deep within this nested structure. Now imagine doing that for thousands of followers and then running a differential to find who isn't following you back. This is precisely where a well-crafted script becomes a game-changer, transforming a tedious task into an automated process.

Python Scripts to Find Unfollowers & Analyze Data

Python, with its powerful data manipulation libraries like Pandas, is a natural fit for this task. Many developers have already built and shared solutions on GitHub. A typical `python script to find unfollowers` involves a straightforward logic: load followers, load following, and find the difference. Let's look at a conceptual example.

How a Python Unfollower Script Works

The core principle is set theory. You create a set of your followers and a set of the accounts you're following. Then, you find the items in your 'following' set that don't exist in your 'followers' set. Simple logic, but powerful results.

Here’s a simplified Python snippet to illustrate the concept:

import json

def parse_instagram_json(file_path):
    """A basic parser to extract usernames from Instagram's JSON structure."""
    with open(file_path, 'r') as f:
        data = json.load(f)
    
    # The exact key might vary, adjust based on your file
    # For older files it might be root key, for newer it might be relationships_followers
    data_list = data.get('relationships_followers', data)

    usernames = set()
    for item in data_list:
        # The data is nested within 'string_list_data'
        if 'string_list_data' in item:
            for user_data in item['string_list_data']:
                usernames.add(user_data['value'])
    return usernames

# --- Main Execution ---
followers = parse_instagram_json('followers_1.json')
following = parse_instagram_json('following.json')

not_following_back = following - followers

print(f"Found {len(not_following_back)} accounts that don't follow you back:")
for user in sorted(list(not_following_back)):
    print(user)

This script provides a solid foundation. You can find numerous variations of this on GitHub, some offering more advanced features like historical tracking or integration with other data points. Leveraging an existing `instagram data python library` can further streamline this process, abstracting away the parsing logic so you can focus on the analysis itself.

Client-Side Power: A JavaScript Instagram JSON Reader

What if you prefer JavaScript or want a solution that runs directly in the browser? No problem. You can build a simple `javascript instagram json reader` using the File API, allowing you to process your `followers_1.json` without any backend setup.

The beauty of this approach is its immediacy. A user can visit a web page, select their JSON files, and get results instantly. It's a fantastic solution for creating a quick, shareable tool.

Building a Basic Browser-Based Parser

The implementation involves an HTML file input and some JavaScript to handle file reading and parsing. The logic remains the same: load both files, extract usernames, and compute the difference.

Here’s a conceptual JavaScript snippet:

// Assuming you have file inputs with ids 'followersFile' and 'followingFile'
const followersInput = document.getElementById('followersFile');
const followingInput = document.getElementById('followingFile');

async function analyzeFiles() {
    const followersFile = followersInput.files[0];
    const followingFile = followingInput.files[0];

    if (!followersFile || !followingFile) {
        alert('Please select both files.');
        return;
    }

    const followersText = await followersFile.text();
    const followingText = await followingFile.text();

    const followersData = JSON.parse(followersText);
    const followingData = JSON.parse(followingText);

    // Helper function to extract usernames
    const getUsernames = (data) => new Set(data.flatMap(item => item.string_list_data.map(user => user.value)));

    const followersSet = getUsernames(followersData);
    const followingSet = getUsernames(followingData);

    const notFollowingBack = [...followingSet].filter(user => !followersSet.has(user));

    console.log('Not following you back:', notFollowingBack.sort());
    // You can now display this list on your webpage
}

// Add event listeners to a button to trigger analyzeFiles()

This client-side approach is perfect for developers who want to `automate instagram analysis` in a lightweight, accessible way. Searching for `parse instagram json github` will reveal several open-source projects that have already built sophisticated user interfaces around this very concept.

DIY Scripts vs. Automated Platforms: A Quick Comparison

Deciding between writing your own script and using a dedicated service? It depends on your goals, time, and technical comfort. Here's a breakdown to help you choose.

A Crucial Word on Security and Your Account Data

When you explore ways to analyze your Instagram data, you'll encounter a minefield of third-party services. Many of these pose a significant security risk. Be extremely cautious of any solution that asks for your account credentials or requires you to provide login details.

Handing over your authentication information can lead to a security breach, unauthorized actions on your behalf, or even a permanent loss of your account. Similarly, avoid services that rely on unauthorized data collection, as this violates Instagram's terms and puts your account in jeopardy.

The safest methods are those that don't need direct access to your account. This is why using your official Instagram data export is the gold standard. Whether you're using a GitHub script to parse the files on your own machine or a privacy-first platform like FollowerAtlas that processes the data in your browser, your credentials are never exposed. Your security is never compromised.