Arc to Chrome Bookmarks Migration Guide (2026): Export Pinned Tabs and Spaces, with a Copy-Paste AI Prompt

Today I moved my Arc bookmarks to Chrome. I had Claude Code read Arc's sidebar file and write a Python script of about 40 lines that turns it into a bookmarks HTML file Chrome can import. I ended up with 270 links and 40 folders, with the folder hierarchy intact. The script only reads Arc's file and changes nothing.

If you don't want the details, copy the prompt below and paste it into Claude Code or Codex. The rest of the page explains what it does, for anyone who wants to check it or do it by hand.

Copy-paste AI prompt: export Arc bookmarks to Chrome

I want to move my Arc browser bookmarks (Pinned Tabs, Spaces and Favorites) to Chrome. This is a Mac.

Please work in this order:
1. Read ~/Library/Application Support/Arc/StorableSidebar.json and inspect its structure before writing anything. The data is in sidebar.containers[1]. Its items, spaces and topAppsContainerIDs arrays alternate between an id string and an object; use only the objects.
2. Write a read-only Python script using only the standard library. Do not modify, move or copy any Arc file.
3. Each Space has containerIDs shaped like ["pinned", <id>, "unpinned", <id>]. Use only the pinned container; unpinned holds temporary tabs, so skip it. Favorites come from topAppsContainerIDs.
4. Rebuild the tree by following childrenIds recursively. data of type tab is a link (URL in savedURL; title from item.title, falling back to savedTitle). list is a folder (name in item.title). itemContainer and splitView should not become folders; flatten the tabs inside them.
5. Write a standard Netscape bookmarks HTML file to ~/Desktop/arc_bookmarks.html. Wrap everything in one top-level "Arc Import" folder, with one folder per Space plus a Favorites folder. HTML-escape titles and URLs.
6. After running it, tell me how many links and folders it exported, then walk me through importing it at chrome://settings/importData and checking it at chrome://bookmarks.

Do not print my bookmark titles or URLs. Counts only.

If you'd rather use an existing tool, paste this instead: "Read main.py in ivnvxd/arc-export on GitHub first. Tell me which files it reads and writes and whether it touches the network, and run it only once we've confirmed it's safe."

Why Chrome can't import from Arc directly

Arc is built on Chromium, but Chrome's "Import bookmarks and settings" page (chrome://settings/importData) doesn't list Arc as a source.

Arc also has no traditional bookmarks and no built-in bookmark export. What works as bookmarks in Arc is the sidebar: Pinned Tabs, Spaces and Favorites. All of it lives in one file:

~/Library/Application Support/Arc/StorableSidebar.json

So the whole job is converting that JSON into a standard Netscape bookmarks HTML file, the format Chrome, Safari and Firefox all import.

How StorableSidebar.json is structured

You'll need this to write the script, or to check the one your AI writes:

• The data sits in sidebar.containers[1], which holds items (every node), spaces (each Space) and topAppsContainerIDs (Favorites).
• Those three arrays alternate between an id string and an object, so each node shows up twice. Keep the objects.
• Each Space has a title and containerIDs shaped like ["pinned", <pinned container id>, "unpinned", <id>]. Take the pinned one only; unpinned holds temporary tabs.
• Each item has an id, title, childrenIds and data. The kinds of data:

data kind	What it is	How to convert it
tab	A link	URL in savedURL; title from item.title, falling back to savedTitle
list	A folder	Name in item.title; becomes a bookmark folder
itemContainer	A container	No folder; walk into it
splitView	A split view holding several tabs	Flatten into plain links

Start from each Space's pinned container and follow childrenIds down to rebuild the whole tree.

No AI: use this script

I wrote this from the structure above and ran it against my own Arc data. It produced the same 270 links and 40 folders as today's migration. It uses only the Python standard library, reads only StorableSidebar.json and writes to your Desktop. The python3 that ships with macOS runs it; the first time, macOS may ask to install the developer tools, so let it.

Save it as arc_to_bookmarks.py and run python3 arc_to_bookmarks.py in Terminal:

import html, json, pathlib

SRC = pathlib.Path.home() / "Library/Application Support/Arc/StorableSidebar.json"
OUT = pathlib.Path.home() / "Desktop/arc_bookmarks.html"

box = json.loads(SRC.read_text())["sidebar"]["containers"][1]
# items, spaces and topAppsContainerIDs alternate: an id string, then its object
items = {i["id"]: i for i in box["items"] if isinstance(i, dict)}
spaces = [s for s in box["spaces"] if isinstance(s, dict)]
counts = {"links": 0, "folders": 0}

def node(item_id, depth):
    item = items.get(item_id)
    if not item:
        return []
    pad, data = "  " * depth, item["data"]
    if "tab" in data:
        counts["links"] += 1
        url = data["tab"].get("savedURL", "")
        title = item.get("title") or data["tab"].get("savedTitle") or url
        return [f'{pad}<DT><A HREF="{html.escape(url)}">{html.escape(title)}</A>']
    kids = [line for c in item.get("childrenIds", []) for line in node(c, depth + 1)]
    if "list" in data:
        counts["folders"] += 1
        return folder(item.get("title") or "Untitled", kids, depth)
    return [line[2:] for line in kids]  # itemContainer, splitView: flatten

def folder(name, lines, depth):
    pad = "  " * depth
    return [f"{pad}<DT><H3>{html.escape(name)}</H3>", f"{pad}<DL><p>", *lines, f"{pad}</DL><p>"]

def children(container_id, depth):
    return [line for c in items.get(container_id, {}).get("childrenIds", []) for line in node(c, depth)]

body = []
for space in spaces:
    ids = space.get("containerIDs", [])
    pinned = ids[ids.index("pinned") + 1] if "pinned" in ids else None
    body += folder(space.get("title") or "Space", children(pinned, 3), 2)
favs = [line for cid in box.get("topAppsContainerIDs", []) if isinstance(cid, str) for line in children(cid, 3)]
body += folder("Favorites", favs, 2)
root = folder("Arc Import", body, 1)

OUT.write_text("\n".join(["<!DOCTYPE NETSCAPE-Bookmark-file-1>",
    '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">',
    "<TITLE>Bookmarks</TITLE>", "<H1>Bookmarks</H1>", "<DL><p>", *root, "</DL><p>"]))
print(f"{counts['links']} links, {counts['folders']} folders -> {OUT}")

The folder count covers Arc's own folders (list items). The wrapper folders for each Space and for Favorites aren't counted.

Importing into Chrome

1. Generate arc_bookmarks.html with the prompt or the script. Keep the "Arc Import" wrapper folder so the import doesn't mix into your existing Chrome bookmarks.
2. Type chrome://settings/importData into Chrome's address bar.
3. Pick "Bookmarks HTML File" as the source and choose arc_bookmarks.html on your Desktop.
4. Open chrome://bookmarks, expand "Arc Import" and check that every Space and folder made it.

Why have AI write the script

With a converter you found online, you're trusting that it does nothing extra. When AI reads your own file and writes the script on the spot, the code is right in front of you. You can require it to be read-only, standard library only and offline, and you can see which file it opens.

StorableSidebar.json isn't a public format either. If its structure changes, an existing tool has to wait for its author; the AI inspects the structure first and writes against the file you actually have.

Things to watch for

• Tabs you haven't pinned won't come over. Temporary tabs in the Today section aren't in the pinned container. Pin anything you want to keep before you migrate.
• This guide covers bookmarks only. Passwords, extensions and history need separate handling.
• Passwords can be exported as a CSV from arc://password-manager/settings and imported into Chrome. The CSV is plain text, so delete it right after the import and empty the Trash.
• History: don't copy Arc's History file over. It would overwrite Chrome's own history, and the format may not match if the two browsers are on different versions.

FAQ

Can Arc export bookmarks? No. Arc has no built-in bookmark export. Pinned Tabs, Spaces and Favorites are stored in StorableSidebar.json, and you convert that file into bookmarks HTML yourself.

Why isn't Arc in Chrome's import list? Chrome's "Import bookmarks and settings" page lists only the browsers it supports, and Arc isn't one of them. Even though Arc runs on Chromium, you go through "Bookmarks HTML File".

Does the folder structure survive? Yes. The script rebuilds the tree from childrenIds, so Arc folders become Chrome bookmark folders, with one folder per Space. Only split views get flattened into plain links.

Can I import the HTML file into Safari or Firefox? Yes. Netscape bookmarks HTML is the format every major browser imports.

Can the script break my Arc setup? No. It only reads StorableSidebar.json and writes its output to your Desktop; it never touches Arc's files. If you use AI, tell it to stay read-only and look over the script before running it.