ChatPassport: carrying a conversation between AI assistants

A draft, not a transfer, and that distinction is the design

ChatPassport moves conversations between ChatGPT, Claude, Gemini and DeepSeek using a local-first open conversation format, with no servers and no tracking. The tag line in the README is short: switch assistants, keep your context.

The mechanism is a Chrome extension that runs in the side panel, and the flow has three steps. You install it, open a conversation on a supported website, open the side panel and choose a destination and a capture mode. You click Prepare for the destination, review a coverage notice and the selected message previews, write your next question, and confirm any older messages that will be omitted. Then you click Open editable draft in the destination, and ChatPassport fills an empty destination editor when it becomes ready.

The last step of that flow is the one to hold onto. ChatPassport does not click Send. You review the draft and press the destination website's own Send button. The README puts it in an important callout: once context is inserted into the editor, the destination website may read or sync the draft before you send it.

That single limitation is the whole ethical and practical shape of the tool. It is not an API integration that sends your conversation to another model provider. It is a text mover that prepares a draft in a browser tab and lets a person decide. The README also offers fallbacks when insertion fails, with Insert prepared draft and Copy prepared draft on the destination card.

The audience is therefore people who already use these assistants daily and want continuity rather than automation.

Capture modes and the coverage notice

Reading a chat out of a web page is harder than it sounds, because the page only renders what it has rendered. ChatPassport offers two capture modes and is honest about what each one gets.

Quick reads the messages currently loaded on the page, with no scrolling, and the coverage is marked as partial. Load history, which is the default, scrolls to collect older rendered messages and then restores your position. It can take up to two minutes, and you can stop it and keep the messages collected so far.

The README then states the hard limit plainly: websites may hide, collapse or virtualize history, so a scan that reaches both page boundaries still cannot guarantee that every past message was captured. That is a real constraint, not a hedge, and it is why the tool shows a coverage notice and lets you look at the selected message previews before it prepares anything.

Two other things happen around the capture. Loading history may trigger the source website's normal requests, since the extension is scrolling and clicking like a reader would. And before continuing you choose all captured messages or the latest 20, 50 or 100, and the tool shows the exact number of older messages that will be omitted and asks you to confirm before opening the draft.

That confirmation step is worth having. A silent truncation would be the failure mode that makes a tool like this untrustworthy, and the fact that the extension counts the omitted messages before you commit is the difference between a tool you can reason about and one you cannot.

What transfers, what does not, and the 48,000 character ceiling

ChatPassport transfers message order and roles, plus the text, code, links, tables and math it can read from the page, and it keeps Markdown formatting where available.

The exclusion list is equally explicit. Images become text placeholders, and image and file contents, artifacts, citation cards and hidden reasoning are not included. So a conversation whose substance lives in a pasted image, a generated artifact or a reasoning trace comes across incomplete, and the extension will not tell you it was looking at a reasoning trace, because it never read one.

Size is the other boundary. A destination draft can contain up to 48,000 characters, including your next question, and the limit is applied to the whole draft rather than to the captured part. JSON files have a 25 MiB limit and pending transfers have a separate 9 MB limit, and the file format details live in docs/format.md.

One design decision deserves credit. The README says ChatPassport never cuts a message in half and never summarizes it with AI. The limit is enforced by dropping whole messages from the older end, and the count of what was dropped is shown and confirmed. A tool that silently truncates a code block mid-function is a debugging session waiting to happen, and this one refuses to do that, and also refuses to hide what it left out.

The privacy model is narrow but checkable

The privacy section describes a local-first design with specific mechanisms, which is more useful than a promise.

Capture begins only when you click Prepare for the destination. ChatPassport needs no account and no API key, and has no developer-operated server, analytics or tracking. The selected conversation and your next question are held in `chrome.storage.session` for one pending transfer, bound to one destination tab, and they expire after one hour.

Those three properties are checkable. There is no backend to send anything to, so there is nothing to log. Session storage is not persistent, and it is tied to one tab, so a transfer cannot leak into a different browser session. The one hour expiry bounds how long a conversation sits in memory.

The honest caveat is where the trust actually sits. The extension reads the DOM of a third party site, which means it runs with the page's privileges, and once a draft is inserted, the destination site handles it under its own policies. The README points at PRIVACY.md for details and says that loading history may trigger the source website's normal requests.

The tool's own claim, no servers and no tracking, is about the developer's infrastructure rather than about what the destination assistant does with the text once it is in the editor. Anyone treating this as a way to move confidential content past an assistant's own terms is reading it wrong.

Building it from source, and the toolchain it uses

The extension is in the Chrome Web Store, but the repository builds locally. The README asks for Node.js 22 and pnpm, and says the repository pins pnpm 11.19.0.

The build is two commands:

pnpm install
pnpm check

`pnpm check` runs type checking, tests and a production build, which in the manifest is `pnpm typecheck && pnpm test && pnpm build`. To try the extension locally you open `chrome://extensions`, enable Developer mode, choose Load unpacked and select `.output/chrome-mv3`. For development there is `pnpm dev`, and `pnpm release:chrome` creates an upload ZIP in `release/`.

The toolchain is visible in the manifest and it is a modern one. The extension framework is wxt, with the React module for the side panel UI, React 19 for the UI, and zod for validation. Tests run on vitest with jsdom for the DOM environment, and typescript is in the toolchain with `tsc --noEmit` for the typecheck step. The `wxt prepare` script runs on postinstall, which is how the framework generates its typed entrypoint glue.

The repository layout follows the framework conventions: `entrypoints/` for the extension entry points, `lib/` for shared code, `public/` and `assets/` for static files, `store-assets/` for the Chrome Web Store listing images, `docs/` for the format documentation, `tests/` for the test suite, and `wxt.config.ts` for the build configuration. There is also a `scripts/copy-release.mjs` step that the release script runs after zipping, which is how the packaged ZIP gets its final layout.

Where this approach does not reach

The first limit is the supported surface. Four assistants and five domains, chatgpt.com, chat.openai.com, claude.ai, gemini.google.com and chat.deepseek.com. A browser with Chrome Manifest V3 and side panel support is required, so this is a desktop Chrome extension and not a cross browser tool.

The second is that capture depends on the layout of someone else's page. The README asks that if a website layout change breaks capture or insertion, you open an issue with the website and steps to reproduce, and it asks you to remove private conversation text first. That last instruction is the practical rule for anyone debugging a capture problem: the reproduction steps you write will contain your conversation.

The third is the content that cannot move. Reasoning, artifacts and citation cards are excluded by design, which means a conversation whose value was in the model's reasoning about a problem arrives as the answer without the working. For a long technical exchange that used the model's reasoning, that can be the whole point of the transfer.

The fourth is the fixed character ceiling. 48,000 characters sounds generous until you compare it with a long debugging session with code in it, and when the limit is hit the answer is to drop older messages, which is exactly the part you wanted to carry over.

The alternative is a different kind of tool. Instead of a browser extension that reads a page, use a provider's own export feature if it has one, or keep notes in a plain text file that you paste into whichever assistant you are using. The second option has no capture fidelity problem and no character limit, and the price is that you maintain the context by hand. The first option is faster and more faithful for the text it can read, which is the trade ChatPassport is betting on. The third option, an API integration that moves conversation state between providers, would be the most reliable of all, and it is exactly the thing this extension deliberately is not.

Editorial conclusion

Adopt ChatPassport when you move between ChatGPT, Claude, Gemini and DeepSeek regularly and the cost of re-establishing context is what you are trying to avoid, and when you are comfortable reading the DOM of another company's page. Do not adopt it for anything confidential, since the extension reads the conversation out of the page and the destination site may read or sync the draft once inserted, and do not expect a full transcript, because images, file contents, artifacts, citation cards and hidden reasoning are explicitly not included. Before you rely on it, read docs/format.md for the compatibility rules, check that a 48,000 character draft is enough for your longest case, and remember that ChatPassport never clicks Send.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. sxwangsxwang1/chatpassport on GitHub