pionxzh/chatgpt-exporter: a Tampermonkey userscript for pulling ChatGPT conversations out of the browser

What pionxzh/chatgpt-exporter actually does

ChatGPT's own data export gives you an archive, not a document. You request it, wait, and receive a bundle you then have to pick apart. ChatGPT Exporter attacks the smaller problem: you are looking at one conversation and you want it as a file, now.

The project describes itself as "A GreasyFork script to export the chat history of ChatGPT". That wording matters. It is a userscript, not an extension, not a desktop app and not a service. It runs inside the ChatGPT page through Tampermonkey, which means the export controls appear where the conversation already is. The intended user is someone who reads or writes in the ChatGPT web interface and wants a shareable or archivable artifact from a single thread: a Markdown file for a notes repository, an HTML page for a colleague, a PNG for a slide, or the raw JSON when the formatted output loses something.

The five documented targets are Text, HTML, Markdown, PNG and JSON. Text is the plain transcript with speaker labels. Markdown adds YAML frontmatter carrying title, source URL and author, which is what makes the output usable in a static site generator or an Obsidian vault. HTML is the visual rendering. PNG is a screenshot. JSON is described as "the raw content from API https://chat.openai.com/backend-api/conversation/[id]", which is the interesting one for anyone doing downstream processing, because it is the unfiltered payload rather than a re-rendering of it.

How the export pipeline works inside the page

The repository layout tells you most of the architecture. There is a src/ directory, a dist/ directory holding the built userscript, a Vite config, and a package.json with vite-plugin-monkey among the dependencies. That plugin is the build step that turns a normal web project into a single .user.js file. The published artifact is dist/chatgpt.user.js, which is exactly the path the README points at for the GitHub install link.

The runtime is a Preact and React application (both preact and react appear in dependencies) mounted into the ChatGPT page, with @headlessui/react and @radix-ui/react-dialog providing the dialog and hover-card primitives, and i18next plus react-i18next handling translations. The README ships translated versions in French, Indonesian, Korean and Turkish, and package.json carries title and description strings for zh-CN and zh-TW, so the UI is localised rather than English-only.

The conversion path is the part worth understanding. The dependencies include mdast, mdast-util-from-markdown, mdast-util-gfm, mdast-util-to-hast, mdast-util-to-markdown, hast-util-to-html and micromark-extension-gfm. That is a Markdown AST pipeline: parse Markdown into an mdast tree, convert to hast, then serialise to HTML or back to Markdown. So the HTML and Markdown exports are produced by walking a syntax tree, not by string-replacing text. Tables, strikethrough and other GFM constructs survive because the GFM extensions are loaded explicitly. jszip is present, which is what would let the script bundle multiple files, and sanitize-filename is there to keep conversation titles from producing invalid file names. sentinel-js and urlcat handle waiting for page elements and building URLs respectively.

One consequence: the JSON export is a passthrough of the API response, while the other four formats go through this conversion stack. If a rendering bug appears in Markdown, the JSON is the fallback that still contains the original data.

Installing the userscript and exporting your first conversation

The prerequisite is Tampermonkey. The README links to the Chrome Web Store, Firefox Add-ons and Edge Add-ons listings for it, and then notes that you must have "Allow User Scripts" enabled in your browser settings for Tampermonkey, pointing at the Tampermonkey FAQ entry Q209. Skipping that step is the most common reason a freshly installed script does nothing.

The script itself installs from one of two places. GreasyFork is the primary distribution channel named in the README, and the GitHub raw URL is the alternative:

https://greasyfork.org/scripts/456055-chatgpt-exporter
https://raw.githubusercontent.com/pionxzh/chatgpt-exporter/master/dist/chatgpt.user.js

Open either link with Tampermonkey already installed and the extension intercepts it with an install prompt. Accept, then load or reload a ChatGPT conversation page. The export controls appear in the conversation interface; the README's screenshot shows them as buttons rather than a keyboard shortcut.

There is no command line here, so a first real use is a browser action. Open a conversation you do not mind discarding, choose Markdown, and you should get a file whose head looks like the README's example:

---
title: ChatGPT Exporter Creation
source: https://chat.openai.com/c/cf3f8850-1d69-43c8-b99b-affd0de4e76f
author: ChatGPT
---

# ChatGPT Exporter Creation

#### You:
I'm creating a ChatGPT Exporter. What do you think?

The frontmatter block is the detail that makes the Markdown export worth choosing over copy-paste: title, source URL and author are written into the file, so the conversation stays traceable after it leaves the browser. If you are building from source instead of installing the published script, package.json declares pnpm@8.14.1 as the package manager and requires Node 20 or newer, with dev, build, test, lint and lint:fix scripts. The test script is tsc --noEmit, so it is a type check rather than a test suite.

Where the userscript approach breaks down

The JSON export is documented as the raw response from the conversation backend endpoint. That is a dependency on an interface OpenAI controls and does not guarantee. When that endpoint's shape changes, the JSON export is the first thing to break, and the Markdown and HTML converters are downstream of the same data. The project has no control over this; it is the structural cost of building on a page you do not own.

The README does not document rollback, version pinning, or what happens when an export fails partway through a long conversation. There is no mention of rate limits, retry behaviour, or a maximum conversation size. If you are exporting a thread with heavy attachments, the README says nothing about how attachments are handled in any of the five formats.

Bulk export is the sharper limitation. The README has a section headed "Export Multiple Conversations", so the feature exists, but the interaction model is still the page: the script is installed into a browser tab and driven by UI controls. There is no documented CLI, no headless mode, and no scheduling. If your requirement is "every conversation I have, refreshed nightly, into a directory", this is the wrong shape of tool. You would be scripting a browser session around a userscript.

Finally, the trust boundary is worth stating plainly. A userscript runs with access to the page it is injected into. The README does not describe a privacy policy or a data-handling statement, and the FAQ answer to whether the script is safe is not something the material addresses. The code is MIT-licensed and the build is reproducible from src/, which is the honest way to evaluate it: read the source or build it yourself rather than taking the GreasyFork listing on faith.

ChatGPT Exporter versus ChatGPT's built-in data export

The real alternative is not another userscript. It is ChatGPT's own account-level data export, and the difference is one of granularity and timing.

The built-in export is account-scoped and asynchronous. You request everything, wait for it to be prepared, and receive a bulk archive. That fits compliance, migration or "I am leaving this service" scenarios, and it does not depend on the page's DOM or on a third-party script running in your browser. It also gives you the whole history in one operation, which the userscript does not.

ChatGPT Exporter is conversation-scoped and synchronous. You pick a format, you get a file, in the tab, immediately. It gives you Markdown with frontmatter, rendered HTML, a PNG screenshot and the raw API JSON, none of which the built-in archive is documented to produce in those shapes. The trade is that you are doing it one conversation at a time, and you are trusting a script injected into the page.

If your output needs to be a document you can commit, share or paste into a wiki, the userscript wins on format. If your output needs to be a complete, unattended copy of everything, the built-in export wins on coverage. They are not substitutes.

Maintenance, release cadence and the MIT licence

The last push to the default branch was on 2026-08-28, the same day userscript-v2.35.0 was released. The two preceding releases, userscript-v2.34.0 and userscript-v2.34.1, landed on 2026-08-20. That is a tight release rhythm in the weeks before the last push, and it is consistent with a project that ships fixes when ChatGPT's interface shifts.

The release tooling is visible in the repository root: release-please-config.json and .release-please-manifest.json, plus a .husky/ directory and a commitlint configuration extending @commitlint/config-conventional in package.json. Commits are conventional-commit formatted and releases are automated, which lowers the cost of shipping a patch. The version in package.json (2.35.0) matches the userscript tag, so the userscript is the product; there is no separate library release to track.

Upgrade cost for a user is close to zero: Tampermonkey checks for script updates and the GreasyFork listing is the update channel. Building from source has a higher floor, since the toolchain expects pnpm 8.14.1 and Node 20 or newer.

The licence is MIT. That permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. It also means there is no warranty and no support obligation. This is a description of what MIT grants, not legal advice; if you are redistributing the script inside a product, read the LICENSE file in the repository root.

Editorial conclusion

Adopt ChatGPT Exporter if you already work in the ChatGPT web UI and want a per-conversation copy in Markdown, HTML, PNG or the raw API JSON without leaving the tab. Skip it if you need a scheduled, unattended archive of every conversation, because the script is driven by buttons in the page and the README documents no headless mode. Before trusting it, open a throwaway conversation, export it as Markdown and as JSON, and check that code blocks and attachments survive the round trip.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. pionxzh/chatgpt-exporter on GitHub
4. README
5. Releases