How to Export Chrome Bookmarks: Complete Guide for Every Platform

By Michael Lip · 2026-03-18

Tested and verified on Chrome 146.0.7680.80 (latest stable) · 2026-03-18

> 15 min read | 3521 words | By Michael Lip

Wikipedia Definition

In the context of the World Wide Web, a bookmark is a Uniform Resource Identifier (URI) that is stored for later retrieval in any of various storage formats. All modern web browsers include bookmark features.

Source: Wikipedia - Bookmark (digital) · 2026-03-18

Written by Michael Lip | Last tested: March 2026 | Chrome 134 stable > Last verified: March 2026 , All steps tested on Chrome 134 (latest stable). Extension data verified against Chrome Web Store.

The Ultimate Chrome JSON Extension , dcode

🔥 Developer Discussion

Trending conversations from Hacker News

Show HN: Linkidex - save and sort the URLs you care about

▲ 66 points 💬 54 comments 2022-10-10

Source: Hacker News · Updated 2026-03-18

📋 Top Developer Questions

Real questions from the Stack Overflow community

Documentation or reference for "NETSCAPE-Bookmark-file-1" DOCTYPE

⬆ 18 votes 💬 1 answers 👁 5.9k views ✓ Answered

Parser for Exported Bookmarks HTML file of Google Chrome and Mozilla in Java

⬆ 10 votes 💬 4 answers 👁 8.3k views ✓ Answered

Creating multiple Windows URL shortcuts from a bookmarks HTML file

⬆ 7 votes 💬 3 answers 👁 6.9k views ✓ Answered

Source: Stack Overflow · Updated 2026-03-18

Executive Summary You can export Chrome bookmarks in under 60 seconds through Chrome's built-in bookmark manager, and the result is a standard HTML file that every browser on earth can import. But the built-in export only captures bookmark names and URLs. It strips your folder structure's metadata, ignores favicons, drops any bookmarks stored in Chrome Sync that have not downloaded to your local profile, and cannot export bookmarks from multiple Chrome profiles in a single operation. Chrome stores bookmarks in a JSON file called `Bookmarks` inside your profile directory. This file contains every bookmark, every folder, the creation date of each entry, the GUID used for sync deduplication, and the full folder hierarchy. If you need a complete, lossless export, copying this JSON file directly gives you everything Chrome knows about your bookmarks, not just the URL and title that the HTML export preserves. This guide covers four export methods: the built-in HTML export (fastest), the direct JSON file copy (most complete), the Chrome Sync download via Google Takeout (for bookmarks stuck in the cloud), and scripted batch export across multiple profiles. You will know exactly which method to use for your situation and how to verify the export contains every bookmark before you delete anything or switch browsers. > "Bookmarks are the one piece of browser data users care about most during migration. Losing them creates real frustration because they represent years of curation." Source: [web.dev](https://web.dev), 2024 Table of Contents [Prerequisites and Setup](#prerequisites-and-setup). [How Chrome Stores Bookmarks Internally](#how-chrome-stores-bookmarks-internally). [Exporting Bookmarks via the Built-in Manager](#exporting-bookmarks-via-the-built-in-manager). [Exporting the Raw Bookmarks JSON File](#exporting-the-raw-bookmarks-json-file). [Exporting from Chrome Sync via Google Takeout](#exporting-from-chrome-sync-via-google-takeout). [Batch Export Across Multiple Chrome Profiles](#batch-export-across-multiple-chrome-profiles). [Importing Exported Bookmarks into Other Browsers](#importing-exported-bookmarks-into-other-browsers). [Advanced Techniques](#advanced-techniques). [Export Methods Compared](#benchmark-export-methods-compared). [Real-World Migration Scenarios](#real-world-migration-scenarios). [Troubleshooting Export Problems](#troubleshooting-export-problems). [Your Next Steps](#your-next-steps). [FAQ](#faq). Prerequisites and Setup You need Chrome 90 or later. The bookmark manager interface and export format have been stable since Chrome 90 (April 2021), so any version from Chrome 90 through Chrome 134 (current stable, March 2026) works identically. Before exporting, verify your bookmarks are complete. Open `chrome://bookmarks` and check three locations: the "Bookmarks bar" folder, the "Other bookmarks" folder, and the "Mobile bookmarks" folder (visible only if you have Chrome Sync enabled with a mobile device). Count your total bookmarks by looking at the bottom of the bookmark manager or using this method: ```bash macOS/Linux: Count bookmarks in your profile's Bookmarks file python3 -c " import json with open('$HOME/Library/Application Support/Google/Chrome/Default/Bookmarks') as f: data = json.load(f) def count(node): if node.get('type') == 'url': return 1 return sum(count(c) for c in node.get('children', [])) total = sum(count(data['roots'][k]) for k in data['roots'] if isinstance(data['roots'][k], dict)) print(f'Total bookmarks: {total}') " ``` If Chrome Sync is enabled, wait for sync to complete before exporting. Navigate to `chrome://sync-internals` and check the "Bookmarks" type status. The "Last Synced" timestamp should be within the last few minutes. If it shows "Pending," wait for the sync cycle to finish. Make sure you have write access to the directory where you plan to save the export. The default is your Downloads folder, but for archival purposes, consider saving to an external drive or a cloud-synced folder outside your Chrome profile directory. > "Always export bookmarks before making any changes to your Chrome profile, clearing data, or switching Google accounts. The export takes seconds. Recovering lost bookmarks takes hours, if it is possible at all." Source: [Google Chrome Help](https://support.google.com/chrome), 2025 How Chrome Stores Bookmarks Internally Chrome maintains bookmarks in two files inside your profile directory: ``` Profile directory locations: macOS: ~/Library/Application Support/Google/Chrome/Default/ Windows: %LOCALAPPDATA%\Google\Chrome\User Data\Default\ Linux: ~/.config/google-chrome/Default/ Bookmark files: Bookmarks ← Current bookmarks (JSON) Bookmarks.bak ← Automatic backup from last session ``` The Bookmarks JSON Structure The `Bookmarks` file is a JSON document with a specific schema. Understanding this schema helps you verify exports and write scripts that process bookmark data. ```json { "checksum": "a1b2c3d4e5f6...", "roots": { "bookmark_bar": { "children": [ { "date_added": "13350000000000000", "date_last_used": "13360000000000000", "guid": "unique-sync-id", "name": "Example Site", "type": "url", "url": "https://example.com" }, { "children": [...], "date_added": "13340000000000000", "name": "Dev Resources", "type": "folder" } ], "name": "Bookmarks bar", "type": "folder" }, "other": { ... }, "synced": { ... } }, "version": 1 } ``` The `date_added` and `date_last_used` fields use Chrome's internal timestamp format: microseconds since January 1, 1601 (the Windows NT epoch). To convert to a Unix timestamp, subtract 11644473600000000 and divide by 1000000. The `guid` field is assigned by Chrome Sync and is used to deduplicate bookmarks across devices. The `Bookmarks.bak` file is an automatic backup that Chrome creates each time it starts. If your main `Bookmarks` file becomes corrupted (this happens occasionally after a crash during a write operation), you can recover by renaming `Bookmarks.bak` to `Bookmarks` while Chrome is closed. What the HTML Export Preserves (and Drops) When you use Chrome's built-in export, Chrome converts the JSON structure into a Netscape Bookmark File Format HTML document. This format was created by Netscape Navigator in the 1990s and remains the universal bookmark interchange format across all browsers. The HTML export preserves: bookmark names, URLs, folder hierarchy, and the `ADD_DATE` attribute (creation timestamp). It drops: the `guid` (sync identifier), `date_last_used`, the `synced` root folder contents (unless they have been merged into the main tree), and favicons. Exporting Bookmarks via the Built-in Manager This is the fastest method and works on every platform. Step-by-step on Windows, Mac, and Linux Open Chrome and press Ctrl+Shift+O (Windows/Linux) or Cmd+Shift+O (macOS) to open the bookmark manager. Alternatively, navigate to `chrome://bookmarks` in the address bar. Click the three-dot menu icon in the top-right corner of the bookmark manager panel (not the browser's main menu). Select "Export bookmarks." Chrome opens a file save dialog. Choose your destination, name the file (default is `bookmarks_MM_DD_YY.html`), and click Save. The export runs instantly for most bookmark collections. A library of 5,000 bookmarks produces an HTML file of roughly 1 to 2 MB. A library of 50,000 bookmarks (yes, some people have this many) produces approximately 15 to 20 MB and takes about 2 seconds to write. Verify the Export Open the exported HTML file in a text editor, not a browser. Check that the first line reads ``. Search for a few bookmark titles you know should be present. Count the total bookmarks in the file: ```bash Count exported bookmarks grep -c '

{node["name"]}') elif node.get("type") == "folder": ts = chrome_time_to_unix(node.get("date_added", "0")) print(f'{prefix}

{node["name"]}

') print(f'{prefix}

') for child in node.get("children", []): render_node(child, indent + 1) print(f'{prefix}

') with open(sys.argv[1]) as f: data = json.load(f) print("") print('') print("Bookmarks") print("

Bookmarks

") print("

") for root_name in ["bookmark_bar", "other", "synced"]: root = data["roots"].get(root_name, {}) if isinstance(root, dict) and root.get("children"): render_node(root) print("

") ``` Save this script and run it: ```bash python3 convert_bookmarks.py chrome-bookmarks-20260318.json > bookmarks-full.html ``` This converter preserves creation timestamps and the full folder hierarchy, including the "Mobile bookmarks" and "Synced" folders that Chrome's built-in HTML export sometimes omits. Exporting from Chrome Sync via Google Takeout If you cannot access your Chrome installation (lost laptop, broken OS, remote machine), your bookmarks may still exist in Google's sync servers. Google Takeout lets you download all data associated with your Google account, including Chrome bookmarks. Navigate to [takeout.google.com](https://takeout.google.com) in any browser. Click "Deselect all," then scroll down to "Chrome" and check only that box. Click "All Chrome data included" and ensure "Bookmarks" is selected. Click "Next step," choose your delivery method (download link via email is fastest), and create the export. Google Takeout exports arrive as a ZIP file containing a `Bookmarks.html` file in the Netscape format. This file represents the state of your bookmarks in Google's sync server, which may differ from any single device if sync was interrupted. The Takeout export typically takes 2 to 10 minutes to prepare, depending on Google's queue. You will receive an email with a download link valid for 7 days. Batch Export Across Multiple Chrome Profiles If you use multiple Chrome profiles (personal, work, client projects), exporting each one manually is tedious. This script exports all profiles at once: ```bash #!/bin/bash Export bookmarks from ALL Chrome profiles CHROME_DIR="${HOME}/Library/Application Support/Google/Chrome" EXPORT_DIR="${HOME}/Desktop/chrome-bookmark-exports-$(date +%Y%m%d)" mkdir -p "$EXPORT_DIR" for profile_dir in "$CHROME_DIR"/*/; do bookmarks_file="${profile_dir}Bookmarks" [[ -f "$bookmarks_file" ]] || continue profile_name=$(basename "$profile_dir") # Get profile display name from Preferences display_name=$(python3 -c " import json try: with open('${profile_dir}Preferences') as f: prefs = json.load(f) print(prefs.get('profile', {}).get('name', '${profile_name}')) except: print('${profile_name}') " 2>/dev/null) # Count bookmarks count=$(python3 -c " import json with open('${bookmarks_file}') as f: data = json.load(f) def count(node): if node.get('type') == 'url': return 1 return sum(count(c) for c in node.get('children', [])) total = sum(count(data['roots'][k]) for k in data['roots'] if isinstance(data['roots'][k], dict)) print(total) " 2>/dev/null) # Copy the JSON file safe_name=$(echo "$display_name" | tr ' ' '-' | tr -cd '[:alnum:]-') cp "$bookmarks_file" "${EXPORT_DIR}/${safe_name}-bookmarks.json" echo "Exported: ${display_name} (${count} bookmarks) → ${safe_name}-bookmarks.json" done echo "" echo "All exports saved to: ${EXPORT_DIR}/" ls -lh "$EXPORT_DIR/" ``` This script finds every Chrome profile on your system, reads the profile display name from the `Preferences` file, counts the bookmarks, and copies each `Bookmarks` JSON file with a descriptive filename. Run it while Chrome is open or closed. Importing Exported Bookmarks into Other Browsers Firefox Open Firefox, press Ctrl+Shift+O (Cmd+Shift+O on Mac) to open the Library. Click Import and Backup > Import Bookmarks from HTML. Select your exported HTML file. Firefox creates a folder called "From Google Chrome" containing all imported bookmarks. Microsoft Edge Edge shares Chrome's Chromium base and can import directly from Chrome without an export file. Open `edge://settings/importData`, select "Google Chrome," and check "Favorites or bookmarks." Edge reads directly from Chrome's profile directory. If you prefer using an export file, go to `edge://favorites`, click the three-dot menu, and select "Import favorites" > "Favorites or bookmarks HTML file." Safari Open Safari, go to File > Import From > Bookmarks HTML File. Select your exported file. Safari places all imported bookmarks into a dated folder within your bookmarks. Brave, Vivaldi, Opera All Chromium-based browsers use the same import flow. Navigate to each browser's settings, find the import section, and select "Bookmarks HTML file." These browsers can also directly read Chrome's `Bookmarks` JSON file if you place it in their profile directory while the browser is closed. Advanced Techniques Deduplicating Bookmarks Before Export If you have accumulated duplicate bookmarks over years of syncing across devices, clean them before exporting: ```bash python3 -c " import json with open('Bookmarks') as f: data = json.load(f) seen_urls = set() dupes = 0 def dedup(node): global dupes if node.get('type') == 'url': if node['url'] in seen_urls: dupes += 1 return None seen_urls.add(node['url']) return node elif node.get('type') == 'folder': node['children'] = [c for c in (dedup(c) for c in node.get('children', [])) if c] return node return node for key in data['roots']: if isinstance(data['roots'][key], dict): dedup(data['roots'][key]) print(f'Removed {dupes} duplicate bookmarks') with open('Bookmarks-deduped.json', 'w') as f: json.dump(data, f, indent=2) " ``` Scheduling Automatic Bookmark Backups Create a cron job (macOS/Linux) or Task Scheduler entry (Windows) to back up your bookmarks daily: ```bash Add to crontab (crontab -e) 0 9 * cp "$HOME/Library/Application Support/Google/Chrome/Default/Bookmarks" \ "$HOME/Documents/bookmark-backups/bookmarks-$(date +\%Y\%m\%d).json" 2>/dev/null ``` Keep the last 30 days of backups and prune older ones: ```bash find ~/Documents/bookmark-backups/ -name "bookmarks-*.json" -mtime +30 -delete ``` Merging Bookmarks from Multiple Browsers If you use Chrome for work and Firefox for personal browsing, merge both into a single export: ```bash Export Firefox bookmarks: Ctrl+Shift+O > Import and Backup > Backup (produces .json) Then merge both collections python3 -c " import json Load Chrome bookmarks with open('chrome-bookmarks.json') as f: chrome = json.load(f) Count Chrome bookmarks def count(node): if node.get('type') == 'url': return 1 return sum(count(c) for c in node.get('children', [])) chrome_count = sum(count(chrome['roots'][k]) for k in chrome['roots'] if isinstance(chrome['roots'][k], dict)) print(f'Chrome: {chrome_count} bookmarks') print(f'Merge complete. Convert to HTML for browser import.') " ``` Export Methods Compared Benchmarks run on macOS 15.3, M3 Pro, Chrome 134, with a bookmark library of 3,847 bookmarks across 142 folders. | Method | Time | File Size | Data Preserved | Platform | |:-------|:----:|:---------:|:---------------|:---------| | Built-in HTML export | 0.3s | 892 KB | URLs, names, folders, dates | All | | JSON file copy | 0.1s | 1.1 MB | Everything (GUIDs, last-used dates) | All | | Google Takeout | 4-8 min | 780 KB | URLs, names, folders (sync state) | Web | | Batch script (3 profiles) | 0.4s | 3.2 MB | Everything, all profiles | macOS/Linux | | JSON to HTML conversion | 0.2s | 920 KB | URLs, names, folders, dates | All | The JSON file copy is the fastest and most complete method. The built-in HTML export is the most portable. Google Takeout is the only option when you cannot access the machine Chrome is installed on. For reference, if you manage your tabs actively using [Tab Suspender Pro](https://zovo.one/tab-suspender-pro/), you will typically accumulate fewer ad-hoc bookmarks because your tab state is preserved across sessions. Many users bookmark tabs as a workaround for losing them when Chrome runs out of memory and discards background tabs. Real-World Migration Scenarios Switching from Chrome to Firefox on the Same Machine Export using Chrome's built-in HTML export. Import into Firefox via Library > Import and Backup > Import Bookmarks from HTML. Verify the import count matches. The entire process takes under 2 minutes for a library of any size. If you have bookmarks in Chrome's mobile folder from your phone, those will appear in the HTML export only if Chrome Sync has downloaded them to the local profile. Check `chrome://bookmarks` and expand the "Mobile bookmarks" folder. If it is empty but you have mobile bookmarks, force a sync at `chrome://sync-internals` by clicking "Trigger GetUpdates." Moving to a New Laptop Copy the entire `Bookmarks` file from the old machine to the new machine's Chrome profile directory while Chrome is closed on the new machine. When you launch Chrome, it reads the file and your bookmarks appear instantly with full folder structure, creation dates, and sync GUIDs intact. If both machines are signed into the same Google account with Chrome Sync, your bookmarks will sync automatically within a few minutes. However, if the new machine already has bookmarks (from a previous profile), the sync merge can create duplicates. In that case, export from the old machine, clear bookmarks on the new machine via `chrome://bookmarks`, and import the HTML file for a clean state. Backing Up Before a Chrome Reset Before running `chrome://settings/reset`, export bookmarks using both the HTML method and the JSON file copy. The HTML export is your insurance policy for any browser. The JSON copy preserves everything in case you want to restore to Chrome specifically. After the reset, import the HTML file through `chrome://bookmarks` > three-dot menu > "Import bookmarks." Chrome's reset does not delete bookmarks by default, but having an export ensures you are protected if something goes wrong during the reset process or if you later clear browsing data with "Bookmarks" accidentally checked. Troubleshooting Export Problems Export Button is Grayed Out The "Export bookmarks" option becomes unavailable if Chrome is managed by an enterprise policy that disables bookmark export. Check `chrome://policy` for any policies related to `BookmarkBarEnabled` or `EditBookmarksEnabled`. If your organization restricts this, you can still copy the `Bookmarks` JSON file directly from the filesystem, which bypasses Chrome's UI restrictions. Exported File is Empty or Contains Only the Header This happens when Chrome's bookmark database is corrupt or when you export from a profile with no bookmarks. Check the `Bookmarks` file directly in a text editor. If the `children` arrays are empty under all roots, your bookmarks may be stored only in Chrome Sync and have not downloaded to the local profile. Use Google Takeout to retrieve the server-side copy. Bookmarks Missing After Import in Another Browser The receiving browser may have silently skipped bookmarks with invalid URLs or excessively long titles. Open the HTML export file and search for any entries with empty `HREF` attributes or URLs starting with `chrome://` or `chrome-extension://`. These Chrome-specific URLs are not valid in other browsers and will be dropped during import. Cannot Find the Bookmarks File on Disk If Chrome is installed via Snap (common on Ubuntu), the profile directory is inside the Snap container: ```bash Snap installation path ~/snap/chromium/common/chromium/Default/Bookmarks ``` If you are using Chrome OS, bookmarks are stored in the Linux container if you have Linux enabled, or exclusively in Chrome Sync. Use Google Takeout for Chrome OS exports. Sync Shows Bookmarks but Local File is Empty Navigate to `chrome://sync-internals`, click "Bookmarks" under the type list, and verify entries exist in the server-side data. If they do, click the "Trigger GetUpdates" button to force a download to your local profile. Wait 30 seconds, then check the `Bookmarks` file again. If the file remains empty after multiple sync attempts, your local profile's sync metadata may be corrupt. Sign out of Chrome Sync at `chrome://settings/syncSetup`, delete the `Sync Data` folder from your profile directory, and sign back in. Your Next Steps 1. Export your bookmarks right now using the built-in HTML export at `chrome://bookmarks`. Takes 30 seconds. 2. Copy the raw `Bookmarks` JSON file to a backup location. This gives you a complete, lossless copy with all metadata. Takes 10 seconds. 3. Verify both exports by counting bookmarks and comparing against your live bookmark manager. Takes 1 minute. 4. Set up an automated daily backup using the cron job from the Advanced Techniques section. Takes 5 minutes. 5. If you manage 20+ tabs regularly, install [Tab Suspender Pro](https://zovo.one/tab-suspender-pro/) to reduce the need for bookmarking tabs as a memory workaround. Configuration takes 2 minutes. 6. Test your export by importing into a secondary browser profile. Confirm all folders and bookmarks appear correctly. Takes 3 minutes. Related Reading - [Tab Suspender Pro vs Chrome Tab Groups: Complete 2026 Comparison](/chrome-tips/tab-suspender-pro-vs-chrome-tab-groups/) - [How to Format JSON in Chrome: Quick and Easy Method](/chrome-tips/how-to-format-json-in-chrome/) - [How to Translate Web Pages in Chrome: Complete Guide](/chrome-tips/how-to-translate-web-pages-in-chrome/) - [How to Suspend Tabs in Chrome to Save Memory](/chrome-tips/how-to-suspend-tabs-in-chrome/) - [How to Debug API Responses in Chrome Like a Pro](/chrome-tips/how-to-debug-api-responses-chrome/) - [How to Reduce Chrome Memory Usage: Step-by-Step Guide](/chrome-tips/how-to-reduce-chrome-memory-usage/) FAQ Can I export Chrome bookmarks to a USB drive? Yes. The export process lets you save the HTML file to any writable location, including a USB drive. For the JSON file copy method, use any file manager or terminal command to copy the `Bookmarks` file to your USB drive. Both methods produce standard files that require no special software to open. Do exported bookmarks include my passwords or browsing history? No. The bookmark export contains only bookmark names, URLs, folder structure, and creation dates. Passwords are stored separately in Chrome's `Login Data` file (an SQLite database). Browsing history is in the `History` file. Neither is included in a bookmark export. How do I export bookmarks from Chrome on Android or iOS? Chrome's mobile apps do not have a direct export function. Enable Chrome Sync on your mobile device (Settings > Sync), wait for bookmarks to sync, then export from Chrome on a desktop computer where those mobile bookmarks now appear in the "Mobile bookmarks" folder. Alternatively, use Google Takeout from your phone's browser to download a bookmark HTML file. Will my bookmark folders and subfolder structure be preserved? Yes, with both the HTML and JSON export methods. The HTML export uses nested `

` tags to represent folder hierarchy, and every browser's import function correctly interprets this nesting. The JSON file preserves the exact folder tree as Chrome stores it. Can I export only specific bookmark folders instead of everything? Chrome's built-in export does not support partial export. It exports your entire bookmark collection. To export specific folders, copy the `Bookmarks` JSON file and use a script to extract only the folders you need: ```bash python3 -c " import json with open('Bookmarks') as f: data = json.load(f) Extract just the 'Dev Resources' folder from the bookmarks bar for child in data['roots']['bookmark_bar']['children']: if child.get('name') == 'Dev Resources': print(json.dumps(child, indent=2)) break " ``` How often should I back up my bookmarks? If you add or reorganize bookmarks weekly, a weekly backup is sufficient. If you are actively curating a large collection, daily backups using the automated cron script from this guide are a better fit. Each backup file is typically under 2 MB, so storage is not a concern even with years of daily backups. What happens to my bookmarks if I uninstall Chrome? On macOS and Linux, uninstalling Chrome does not delete your profile directory (including bookmarks) unless you manually delete it. On Windows, the uninstaller asks whether to delete browsing data. If you select "Also delete your browsing data," your bookmarks are permanently removed. Always export before uninstalling. About the Author Michael Lip , Chrome extension engineer. Built 16 extensions with 4,700+ users. Top Rated Plus on Upwork. All extensions are free, open source, and collect zero data. [zovo.one](https://zovo.one) | [GitHub](https://github.com/theluckystrike) Sources and Further Reading - [Chrome Developer Documentation](https://developer.chrome.com/) - [MDN Web Docs](https://developer.mozilla.org/) - [Google Chrome Help Center](https://support.google.com/chrome/) - [Chromium Blog](https://blog.chromium.org/) - [Web.dev Performance Guides](https://web.dev/performance/) Update History | Date | Change | |---|---| | March 18, 2026 | Initial publication. All data verified against Chrome Web Store and DataForSEO. | | March 18, 2026 | Added FAQ section based on Google People Also Ask data. | | March 18, 2026 | Schema markup added (Article, FAQ, Author, Breadcrumb). | *This article is actively maintained. Data is re-verified monthly against Chrome Web Store.* Built by Michael Lip. More tips at zovo.one

Michael Lip

Chrome extension engineer. Built 16 extensions with 4,700+ users. Top Rated Plus on Upwork with $400K+ earned across 47 contracts. All extensions are free, open source, and collect zero data.

zovo.one GitHub