How to Export Your GitHub Stars to Markdown (The Lazy Developer's Guide)

If you've been using GitHub for a while, you've probably accumulated hundreds—or maybe thousands—of starred repositories.

Each one represents a late-night rabbit hole.

A useful library.

An interesting tool.

A project that made you think,

"I should definitely come back to this someday."

But here's a question:

What happens if you lose access to your GitHub account?

Or GitHub has an outage?

Or maybe you simply want all those repositories inside your own note-taking system where you can search and organize them however you like.

That's where Markdown comes in.

It's simple, future-proof, readable, and supported almost everywhere.

Let's look at a few different ways to export your GitHub Stars.

Why Markdown?

There are plenty of export formats.

JSON.

CSV.

SQLite.

Whatever you like.

But Markdown has a few advantages that are hard to beat.

First, it's human-readable. Open it in any text editor and you're done.

Second, every major note-taking app supports it—Obsidian, Notion, Logseq, Joplin, and many others.

Third, it works beautifully with Git. Changes are easy to track using git diff, so you can see exactly how your collection evolves over time.

And finally, it's just plain text.

Twenty years from now, you'll almost certainly still be able to open it.

Option 1: Use the GitHub API (Maximum Flexibility)

If you're comfortable with the command line, the GitHub API gives you complete control.

Start by creating a Personal Access Token in your GitHub account settings.

For exporting public Stars, read-only permissions are all you need.

Then fetch your repositories with curl:

curl -H "Authorization: token YOUR_TOKEN" \
     -H "Accept: application/vnd.github.v3+json" \
     "https://api.github.com/user/starred?per_page=100&page=1"

Once you have the JSON response, convert it into Markdown.

A minimal Python example looks like this:

import json
import sys

stars = json.load(sys.stdin)

for repo in stars:
    print(f"## [{repo['full_name']}]({repo['html_url']})")
    print(f"Stars: {repo['stargazers_count']} | Language: {repo['language'] or 'N/A'}")
    print(repo['description'] or "No description")
    print()

One thing to remember is pagination.

GitHub returns at most 100 repositories per request, so you'll need to follow the Link header until you've retrieved everything.

This approach is powerful, but it also means maintaining your own script.

You'll need to handle pagination, rate limits, authentication, and remember to rerun the export whenever you want an updated backup.

Option 2: Copy Everything from the GitHub Website

If you're only doing this once and don't want to touch the command line, you can export directly from GitHub's website.

Open your Stars page:

https://github.com/YOUR_USERNAME?tab=stars

Scroll until every repository has loaded.

If you have hundreds or thousands of Stars...

...this may take a while.

After that, use a browser extension that can copy page content as Markdown, then paste everything into a Markdown file.

It's the quickest approach, but also the least reliable.

Every export is completely manual.

If the page doesn't fully load, you'll miss repositories.

And you'll have to repeat the entire process every time.

Option 3: Use an Open Source Export Script

Several open source tools already wrap the GitHub API for you.

Instead of writing everything yourself, you can simply run an existing project.

Some examples include:

• starred by amirhmoradi, which exports all of your Stars into a single Markdown file.
• starred-repo-exporter, which provides additional formatting options and can even include repository summaries.
• gh-star-export, which authenticates using GitHub's official gh CLI instead of requiring a manually configured token.

These tools eliminate most of the boilerplate.

However, you'll still need some command-line knowledge, install dependencies, and rerun the export whenever your collection changes.

Option 4: Use GitHub Backup

If you'd rather avoid scripts entirely, I built GitHub Backup for exactly this problem.

After connecting your GitHub account, simply open your dashboard, choose Export Markdown, and wait for the file to be generated.

The exported file includes:

• Repository name
• Repository URL
• Description
• Star count

Pro users also get:

• AI-generated categories
• Technology tags
• One-sentence summaries

Exports are generated asynchronously, so you don't have to wait while thousands of repositories are fetched page by page.

Completed exports remain available for seven days.

A typical export looks something like this:

# My GitHub Repositories

## Web Development

- vercel/next.js
  React Framework
  Stars: 128K
  Language: TypeScript

## Artificial Intelligence

...

Like every export solution, this is still a snapshot.

If you Star new repositories later, you'll need to generate a fresh export.

How Do You Keep Your Backup Up to Date?

Exporting once is easy.

Keeping it current is the real challenge.

There are two common approaches.

The simplest option is setting a recurring reminder.

Export your Stars once a month—or once every quarter—and you're done.

The better option is automation.

If you're using the GitHub API or an open source script, you can schedule it with GitHub Actions.

For example, run the export every week and automatically commit the updated Markdown file into a Git repository.

Now you've built a version-controlled history of your entire collection.

What Can You Do with the Markdown File?

Once everything lives in Markdown, lots of interesting possibilities open up.

Import it into Obsidian or Logseq and search it alongside your personal notes.

Commit it to Git for version-controlled backups.

Store it in cloud storage like Google Drive or Amazon S3.

Or even feed it into ChatGPT or Claude and ask questions like:

> Which testing frameworks have I starred?

or

> Show me all the Rust networking projects I've saved.

You can even share it with teammates as a curated list of useful resources.

Final Thoughts

Your GitHub Stars aren't just bookmarks.

They're part of your personal knowledge base.

Exporting them to Markdown is simply a way of taking ownership of that knowledge instead of leaving it locked inside someone else's platform.

If you want complete control, use the GitHub API.

If you want something simpler, use one of the open source exporters.

And if you'd rather click one button and let everything happen automatically, give GitHub Backup a try.