What is this?

This is a really simple tool which allows you to generate graphs showing who invited whom on your Facebook groups. You need administrative access to the group you want to graph.

How does it do that?

This is just a parser for "dead" text, and it works offline. There is no online tool that needs access to your group or account, this is 100% DIY on your computer.

What do I need?

Everything you need is open source, or at least free – you don't need to buy any software license. You will need:

Administrative access to a Facebook group
A computer (everything is cross-platform, the OS is irrelevant)
The .NET Core SDK – make sure you install the SDK, so you can build the sources!
Some software to render DOT files; I like Gephi, but there are several options
The sources for this project

What do I get?

You get a DOT file, which you can then render using any number of graph generation tools, such as graphviz. I used Gephi to render this for a group I administer (and yes, you can render the names, too; I chose not to, for privacy reasons):

Using this app

Using the app is a little cumbersome, but that's the price you pay in order to avoid integration with other tools. Make sure you carefully go through all steps, it's easy to miss some, and it won't work if you miss any:

Open your Facebook group's "Members" section
Above "All Members" there's a dropdown which defaults to "Default" – change it to "Join Date"
Scroll down until you reach the very end. Facebook loads the list in increments, this is tedious and takes time. I use the End key repeatedly, I find it easier than scrolling using the mouse wheel.
The last person you see should be the founder of the group. Even if the founder has left the group, we'll call the last person in the list the founder for the rest of this document.
Click once somewhere in the founder's details, after his name; DO NOT CLICK ANYWHERE AGAIN UNTIL THIS DOCUMENT TELLS YOU OTHERWISE!
Notice that you are a monkey who takes orders from a document; take a couple of moments to contemplate on that
Scroll back up to the top
Holding the Shift key, click once somewhere inside the label "All members"
You should now have the entire list of members selected. Copy it and paste it in a new text document
Make sure the first thing in the text document is the name of the newest member in the group (your clipboard will contain some clutter at the top)
Save the text file, and save its full path separately for future reference
Open a command line console, go to the folder where you saved these sources, and build the project – you should be able to simply execute dotnet build with no parameters
Execute the app using the following syntax: dotnet run --no-build "file", where file is the full path and filename of the text file you saved before
If everything works out, you should get the list of members in the console, and a new file with the same path and filename as your text file, but with extension DOT.
Use a graph rendering tool to render your DOT file.

But does it scale?

Yes, it scales reasonably well. I tested it on a +20K group, and it worked perfectly. The only hard limitation I encountered was Facebook's unwillingness to share data on more than roughly 10K users (see below); apart from that, everything worked out perfectly.

Known limitations

Duplicate people's names in the group are handled poorly, but that's on Facebook (see below)
There's a limit of roughly 10K people you can ever see in the history, but that's also on Facebook(*)
You miss parts of the history when people leave the group and then re-join; this is partly on Facebook, but also partly on this app, because it currently only allows you to process a single snapshot of the history(*)
There is currently no option to anonymize the data; that's on this app
There is currently no option to filter the DOT output, but I'm not sure that should ever be included in this app

(*) I suggest you save multiple versions of your group's history as text files. Perhaps this app will process them, in a future version; perhaps you will – just don't lose that history, because you might not get it back.

How does it handle duplicate names?

Short answer: as best it can.

Facebook shows group additions like so:

Jane Doe
Added by John Doe yesterday

Jane Doe is listed with her full details (image, profile link, short info). If we parsed the HTML content instead of the plain text representation, we could distinguish between two accounts with the name Jane Doe. On the other hand, John Doe is only shown as plain text – even in the HTML source. There is nothing distinguishable between two people named John Doe when they add people to the group.

Since there's no way of knowing who added a certain person to the group, that means we don't really care to ever distinguish between duplicate accounts – it doesn't matter that you can distinguish between incoming nodes if you can't distinguish the outgoing nodes on an edge.

So the solution I implemented was this: all Jane Does are separate nodes, but all outgoing references use the first instance of Jane Doe that was encountered. The names in the labels are Jane Doe, Jane Doe@2, Jane Doe@3, etc. The code is not testing if it generates new duplicates by appending these indices because I was lazy.

Gutza / FacebookGroupMemberGrapher