Exporting Browser Bookmarks (Chrome/Firefox) to JSON

Hey team, Darian here. A few months back, I was trying to build a personal search index for all the articles, docs, and Stack Overflow answers I’d saved over the years. The problem was, they were all locked inside my browser’s bookmark system. Manually exporting and cleaning them was a non-starter. I realized I was spending way too much time hunting for links I knew I had. That’s when I built this little Python utility to programmatically pull and flatten that data into clean JSON. It’s been a game-changer for building internal knowledge bases and automating research logs. Let’s walk through how you can do it too.

Prerequisites

Before we start, make sure you have the following:

• Python 3.6 or higher installed.
• Access to your browser’s user profile directory.
• A basic understanding of JSON data structures.

The Guide: Step-by-Step

Step 1: Locate Your Browser’s Bookmarks File

First, you need to find the raw bookmarks file. It’s a plain file named ‘Bookmarks’ (with no extension) located deep inside the browser’s profile folder. Make sure your browser is closed before you try to copy this file, as it can sometimes be locked while the browser is running.

Here are the typical locations:

• Google Chrome (Windows): C:\Users\[Your_Username]\AppData\Local\Google\Chrome\User Data\Default\Bookmarks
• Google Chrome (macOS): ~/Library/Application Support/Google/Chrome/Default/Bookmarks
• Google Chrome (Linux): ~/.config/google-chrome/Default/Bookmarks
• Mozilla Firefox: Firefox is a bit different. It uses a database. The easiest way is to export an HTML file first (Bookmarks > Manage Bookmarks > Import and Backup > Backup…). We’ll focus on the Chrome JSON structure here as it’s more direct, but the same Python logic can be adapted for a parsed HTML file.

For this guide, copy that ‘Bookmarks’ file into your project directory for easier access.

Pro Tip: If you use multiple Chrome profiles, the folder won’t be ‘Default’. It will be named ‘Profile 1’, ‘Profile 2’, etc. Find the right one by checking which profile you’re logged into.

Step 2: The Python Script – Parsing the Nested Data

Alright, let’s get to the code. The ‘Bookmarks’ file is already JSON, but it’s a deeply nested mess. We need a script to traverse this tree and pull out only what we need: the name and URL of each bookmark.

I’ll skip the standard virtualenv setup since you likely have your own workflow for that. The only library we need is `json`, which is built into Python, so no external package installation is required. Just create a Python file, let’s call it `parse_bookmarks.py`.

Here is the full script. I’ll break down the logic below.

import json

def parse_node(node, bookmarks_list):
    """Recursively traverses the bookmark tree."""
    if node.get('type') == 'url':
        # This is a bookmark, not a folder. Extract it.
        name = node.get('name', 'N/A')
        url = node.get('url', '#')
        if url != '#':
            bookmarks_list.append({'name': name, 'url': url})
    elif node.get('type') == 'folder':
        # This is a folder, so we need to check its children.
        if 'children' in node:
            for child in node['children']:
                parse_node(child, bookmarks_list)

def main():
    """Main function to read, parse, and write bookmarks."""
    input_file = 'Bookmarks'
    output_file = 'bookmarks_flat.json'
    flat_bookmarks = []

    try:
        with open(input_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: The file '{input_file}' was not found.")
        return
    except json.JSONDecodeError:
        print(f"Error: Could not decode JSON from '{input_file}'.")
        return

    # The actual bookmarks are stored under the 'roots' key.
    roots = data.get('roots', {})
    for root_name, root_node in roots.items():
        parse_node(root_node, flat_bookmarks)

    # Now, write the clean list to a new file.
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(flat_bookmarks, f, indent=4, ensure_ascii=False)

    print(f"Successfully exported {len(flat_bookmarks)} bookmarks to {output_file}")

if __name__ == '__main__':
    main()

Step 3: Understanding the Logic

So what’s happening here? It’s simpler than it looks.

1. `main()` function: This is our entry point. It defines the input and output filenames, opens the copied ‘Bookmarks’ file, and uses the `json` library to load it into a Python dictionary.
2. The `roots` Key: The entire bookmark structure lives under a top-level key called `roots`. Inside `roots`, you’ll find keys like `bookmark_bar`, `other`, and `synced`. We need to iterate through all of them.
3. `parse_node()` function: This is the core of the script. It’s a recursive function, which means it calls itself.
   • If it’s given a node with `type` equal to `url`, it knows it’s a bookmark. It grabs the `name` and `url` and appends them to our `flat_bookmarks` list.
   • If the node’s `type` is `folder`, it dives into that folder’s `children` list and calls itself for each child.
   • This process continues until every folder and sub-folder has been explored.
4. Writing the Output: Finally, the `main` function takes our flat list of bookmarks and writes it to `bookmarks_flat.json` in a nicely formatted way.

Pro Tip: In my production setups, I parameterize the input and output file paths using command-line arguments (with `argparse`) or environment variables from a `config.env` file. This makes the script much more flexible for automation.

Common Pitfalls

Here’s where I usually mess up when I’m moving too fast:

• Browser is Still Open: The number one issue. You try to copy the Bookmarks file, and it’s either locked or you get an older, cached version. Always close the browser completely first.
• Incorrect File Path: Especially with multiple profiles, grabbing the Bookmarks file from the wrong profile directory is a common mistake. Double-check that you’re in the active profile.
• File Permissions: On Linux or macOS, you might run into permission errors when trying to access the config directories programmatically. For a scheduled job, ensure the user running the script has read access to that path.

Conclusion

And that’s it. You now have a simple, reliable way to turn your browser’s nested bookmark collection into a clean, flat JSON file. From here, you can load it into a database, feed it into a search engine like Elasticsearch, or just use it as a portable backup. Automating the small, tedious tasks is a cornerstone of good DevOps, and this is a perfect example of a quick win that pays off over time.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions