Topic: chatgpt shared links export
ChatGPT Shared Links: What Persists, What Expires, and How to Archive Conversations (2026)
Senior engineers frequently paste a ChatGPT shared link into a GitHub PR description, a Slack thread, or a Confluence page as evidence of the reasoning behind a decision. The link is convenient. It's also fragile: it's a frozen snapshot that doesn't update as the conversation grows, it doesn't appear in the ChatGPT data export, and it can 404 without warning when accounts are deleted, links are revoked, or OpenAI removes it. Using a shared link as the durable record of an important decision is one of the most common informal documentation anti-patterns in engineering teams — and one of the hardest to notice until the link is already gone.
TL;DR
ChatGPT shared links are frozen snapshots, not live views. They capture the conversation up to the moment you created the link and don't update when you add new messages. They are NOT included in the ChatGPT data export (conversations.json). They can disappear when you revoke them, when your account is deleted, or when OpenAI removes them — with no warning. If you've shared a conversation containing important reasoning, archive it now: submit the URL to web.archive.org, print to PDF, or copy the text from conversations.json (the full text IS there even though the share UUID isn't). And stop using shared links as the durable copy — extract the decision into an ADR or use WhyChose.
How ChatGPT shared links work
To share a conversation: open ChatGPT, click the share icon (or the ⋮ menu next to a conversation title), and select "Share conversation." ChatGPT generates a public URL at https://chatgpt.com/share/[UUID]. Anyone with the link can view the conversation — no ChatGPT account required.
The critical behavior: the shared link is a snapshot taken at the moment you click "Create link." It does not update. If you continue the conversation after sharing, the new messages do not appear at the shared link. If you share a link at message 10, and then add messages 11–20, the link still shows only messages 1–10. Viewers who saved or bookmarked the link see the old version. There is no "update link" button that refreshes the snapshot — you'd need to delete the old link and create a new one.
The link URL includes a UUID that is the unique identifier for that specific snapshot. Deleting and recreating the link for the same conversation produces a different UUID at a new URL.
What a shared link shows — and what it doesn't
| Element | Included in shared link? | Notes |
|---|---|---|
| Full conversation text (user + assistant turns) | Yes — up to the moment the link was created | Frozen; new messages added after sharing are not visible |
| Code blocks and pre-formatted text | Yes | Rendered as code; syntax highlighting matches the ChatGPT UI |
| Messages added after the link was created | No | The link is a snapshot; it does not live-update |
| Custom GPT system prompt | No | Remains private to the GPT creator even in shared conversations |
| DALL-E generated images | Partial — expiring | CDN URLs are embedded but 404 after approximately 30 days; see the file uploads export guide |
| Uploaded files (PDFs, images you sent) | No | Files are referenced by name only; binary content is not included |
| Memory context the model used | No | Memory entries that influenced the response are not shown in the shared view |
| Model version used (e.g. GPT-4o, o1) | No | The model name is not displayed in the shared view |
| Conversation title from your sidebar | No | Shared view shows a generic header; your sidebar title remains private |
| Web search results cited in the conversation | Partial | The text citing search results is shown; linked external pages are not archived alongside it |
Are shared links in the data export?
No. The standard ChatGPT data download (Settings → Data controls → Export data → confirm → download the ZIP) produces a conversations.json file. This file contains the full message history of every conversation — every user turn, every assistant response, code blocks, tool calls, everything. What it does NOT contain:
- The share link UUID(s) associated with any conversation
- A flag indicating whether a conversation was ever shared
- The share creation date or share revocation date
In other words: the conversation content is in the export. The fact that you shared it, and the URL you shared, is not. This means if you want to audit which conversations you've shared, you cannot do it programmatically from the export — you have to check each conversation in the ChatGPT UI manually.
To check whether a conversation has an active shared link: open the conversation in ChatGPT, click the share icon. If it says "Manage link" (rather than "Create link"), a link exists. If it says "Create link," no active link exists for that conversation at that moment.
There is no "all my shared links" page in the ChatGPT web interface. This is a known gap — shared links are created per-conversation and there is no aggregate view.
When shared links disappear: four causes
1. User revocation
Click the share icon in the conversation → "Manage link" → "Delete link." The link 404s immediately. There is no grace period; anyone who has it bookmarked or referenced it in a PR description will now get a 404. There's no notification to people who have the link that it's been revoked.
2. Account deletion
When a ChatGPT account is deleted, all shared links associated with it become inaccessible. This is the most common cause of unexpected link disappearance in team contexts: an employee leaves, their account is deleted (or deactivated), and every shared link they created — embedded in PRs, Confluence pages, Slack messages — goes dark. Links in PR descriptions are permanent text; the dead links remain long after the conversation they referenced is gone.
3. OpenAI terms of service enforcement
OpenAI can remove shared links that violate its Terms of Service — for example, links sharing conversations that contain another person's private information, conversations that triggered safety filters, or conversations OpenAI determines shouldn't be publicly accessible. The user does not receive a notification when a link is removed this way. The link simply 404s.
4. Platform changes
OpenAI migrated shared links from chat.openai.com/share/UUID to chatgpt.com/share/UUID during 2024. The old domain redirects to the new one (as of 2026), but platform migrations can change URL formats. There is no guarantee that today's shared link URL will resolve at the same path in three years. This is not a hypothetical concern — it has already happened once.
How to discover your shared links
Three paths, in order of effort:
Path 1: ChatGPT UI (per-conversation check)
Open a conversation → click the share icon → if it says "Manage link," a link exists. This is the only reliable real-time check. It doesn't scale to hundreds of conversations, but for specific conversations you know you shared, it's definitive.
Path 2: Search your own messages for chatgpt.com/share URLs
Search your Slack, email, PR descriptions, Confluence pages, and Notion docs for "chatgpt.com/share" or "chat.openai.com/share." Every time you pasted a shared link somewhere, you left a trace. This finds the links you actually shared with others (as opposed to links you created but never sent). Use the results to prioritize which conversations to archive — these are the links that colleagues have already bookmarked.
Path 3: Check conversations.json for conversations you know you shared
The data export doesn't contain share UUIDs, but it contains the full conversation text. If you remember approximately when a conversation happened and what it was about, you can find it in conversations.json and extract the text from there — the export is the authoritative source of the content even if not the share URL. Use jq to search by title or date:
# Find conversations by approximate title
jq '.[] | select(.title | test("postgres|database"; "i")) | {title, create_time}' conversations.json
# Find conversations in a date range (Unix timestamps)
jq '.[] | select(.create_time > 1700000000 and .create_time < 1720000000) | .title' conversations.jsonFive archival strategies
For any shared link containing reasoning you need to preserve, take one of these actions now rather than waiting for the link to disappear:
Strategy 1: Wayback Machine snapshot (most durable)
Submit the URL to web.archive.org/save/. The Wayback Machine crawls the page and stores a permanent snapshot at a web.archive.org/web/TIMESTAMP/chatgpt.com/share/UUID URL. This is the most durable option: even if ChatGPT removes the link, the Wayback Machine snapshot remains independently hosted. The Wayback Machine does not require an account and is free for individual URLs.
Strategy 2: Browser print to PDF
Open the shared link in a browser → Cmd+P (macOS) or Ctrl+P (Windows/Linux) → "Save as PDF." Preserves the rendered page including code block formatting. Suitable for attaching to a Confluence page or PR description directly. Limitation: DALL-E images that have already expired appear as broken image placeholders in the PDF.
Strategy 3: wget download
Download the full page and its assets locally:
wget -p -k -nd -P ./archive/chatgpt-uuid \
https://chatgpt.com/share/YOUR-UUID-HEREThe -p flag downloads all page assets (CSS, JS); -k converts links to local paths for offline browsing; -nd puts everything in a single directory; -P sets the output directory. This produces a local HTML + assets directory you can open in a browser without network access. Note: the JavaScript bundle required to render the conversation content must be present — this approach works better for archival than for programmatic text extraction.
Strategy 4: Extract text from conversations.json
The most reliable text-extraction path doesn't use the shared link at all — it uses the ChatGPT data export, which contains the full conversation text even though it doesn't contain the share UUID. Find the conversation by title or date in conversations.json, then extract the messages:
# Extract messages from a specific conversation (replace TITLE with your conversation title)
jq '.[] | select(.title == "TITLE") | .mapping | to_entries[].value
| select(.message != null and .message.author.role != "system")
| {role: .message.author.role, content: .message.content.parts[0]}' \
conversations.jsonSee the ChatGPT conversations.json field reference for the full mapping DAG schema and the Markdown conversion guide for the full DAG-walk script that produces one .md file per conversation.
Strategy 5: Run the decision extractor
If the conversation contained an architectural decision — a trade-off analysis, a technical choice, a "why did we pick X over Y" reasoning session — run the WhyChose extractor on the conversations.json file. The extractor finds decision-shaped conversations and outputs structured records with the original reasoning, the alternatives considered, and a backlink to the source conversation. The structured record is more durable than a shared link and more useful as a decision artifact: it's a first-class record in a decisions directory, not a pointer to an external page that may or may not resolve.
The shared-link-as-decision-record anti-pattern
The most common informal documentation pattern that shared links enable goes like this:
- An architect spends 45 minutes in ChatGPT working through a database selection trade-off.
- The reasoning is good — it covers the actual constraints, the rejected alternatives, and the reasoning behind the chosen approach.
- The architect creates a shared link and pastes it into the PR description: "See the full reasoning here: chatgpt.com/share/UUID."
- The PR merges. The conversation link is the only record of the reasoning — there's no ADR, no design doc, nothing in the repository.
- Eighteen months later, a new engineer asks why the database was chosen. The PR description has the link. The link is 404 — the architect left the company and their account was deleted.
This is the exact scenario WhyChose is built to prevent. The shared link was a convenient shortcut that became a dead end. The reasoning existed — it was good reasoning — but it was stored in a platform that didn't persist it durably.
The correct pattern at step 3 is one of:
- Write an ADR from the chat conversation and reference the shared link in the ADR's Context section as supporting evidence. The ADR is the durable record; the shared link is an optional archival reference.
- Run the WhyChose extractor on the conversation and commit the structured output to
doc/decisions/. The extractor produces the ADR-equivalent record directly from the conversation, without manual reformatting. - At minimum, paste the key reasoning into the PR description as plain text — not just the link. Text in a PR description is stored in GitHub/GitLab forever; the link may not be.
Shared links vs the data export: what to use when
| Need | Shared link | Data export (conversations.json) |
|---|---|---|
| Share a conversation with someone right now | Yes — easiest path | No — requires data export request + processing |
| Durable archival of conversation content | No — can 404 without warning | Yes — local copy you control |
| Reference in a PR description or design doc | Use only as supplementary reference; add plain-text summary too | Extract text and embed it; more durable than a link |
| Extract decision reasoning programmatically | No — requires parsing rendered HTML | Yes — structured JSON, parseable with jq |
| Find conversations you've shared | Only via per-conversation UI check | Content is here; share UUIDs are not |
| GDPR data portability (your data) | No — not included in GDPR export | Yes — the canonical GDPR export artifact |
Team workspace: are shared links policy-controlled?
For ChatGPT Team and Enterprise accounts, workspace admins can control data sharing behavior through the admin console. By default, conversations in Team workspaces are not available for OpenAI model training — but the shared link feature operates independently of the training toggle. Admins cannot disable shared links for all workspace members from the admin console (as of 2026); individual users can still create and share links from their accounts. This means conversations with proprietary architectural reasoning can be shared externally by any team member — a governance gap that some regulated organizations address through policy rather than platform controls.
For context on the full Team workspace data picture (admin export, audit log, member scope), see the ChatGPT Team export guide.
How WhyChose fits in
Shared links are a symptom of a real need: the reasoning in your ChatGPT conversations is worth preserving, and teams reach for shared links because they're the only in-platform sharing mechanism. The problem isn't the sharing — it's that the shared link is the only artifact, and it's fragile.
The WhyChose extractor addresses this upstream: it reads your conversations.json export and surfaces every decision-shaped conversation — the trade-off analyses, the "why X over Y" reasoning sessions, the technical choices made with AI assistance — as structured records with the original reasoning, the alternatives considered, and the date. Each record is a first-class ADR-equivalent that belongs in doc/decisions/, not a link to an external page. When a new engineer asks "why did we pick this architecture?" in eighteen months, the answer is in the repository — not behind a URL that may or may not resolve.
Related questions
Are ChatGPT shared links included in the data export?
No. The ChatGPT data export (conversations.json) contains the full message history of every conversation but does NOT include share link UUIDs, a list of which conversations were shared, or share creation/revocation dates. The conversation content is present; the sharing metadata is not. To find which conversations have active shared links, you must check each conversation individually in the ChatGPT UI (the share icon shows "Manage link" if a link exists). There is no "all my shared links" dashboard.
Do ChatGPT shared links expire?
OpenAI doesn't publish a time-based expiry. Links persist until: the user revokes them ("Manage link → Delete link"), the owning account is deleted, OpenAI removes them for ToS violations, or platform changes break the URL structure (which happened once during the chat.openai.com → chatgpt.com migration). There is no expiry warning — disappearance is sudden. For this reason, shared links should be treated as ephemeral references, not durable records. Archive important reasoning from conversations.json or via the Wayback Machine.
What does a ChatGPT shared link show vs the original conversation?
A shared link shows the conversation text up to the moment the link was created — all user and assistant turns, code blocks, and formatting. It does NOT show: messages added after the link was created (it's a frozen snapshot, not a live view), the Custom GPT system prompt if the conversation was in a GPT, DALL-E images after their CDN URLs expire (~30 days), uploaded file contents, the model version used, or the conversation's sidebar title. The view is anonymous — it doesn't show who created the conversation.
How do I permanently archive a ChatGPT shared link?
Five options in order of durability: (1) Wayback Machine — submit to web.archive.org/save/; the snapshot persists even if OpenAI removes the link. (2) Browser print to PDF — Cmd+P or Ctrl+P → Save as PDF. (3) wget download — saves HTML + assets locally for offline browsing. (4) Extract from conversations.json — the full text is there even without the share UUID; use jq to find the conversation by title or date. (5) WhyChose extractor — if the conversation contains architectural decisions, the extractor outputs structured records with the reasoning as the durable artifact rather than a link.
Further reading
- How to export your ChatGPT history (2026 guide) — the standard data export is the authoritative source for conversation content, even though it doesn't include share link UUIDs. This guide covers the full export flow (Settings → Data controls → Export data), what's in the ZIP, and what to do when the export email doesn't arrive.
- ChatGPT conversations.json format — field reference — the field-by-field schema for the export file, including the mapping DAG that represents the conversation tree. Essential for writing jq queries to find specific conversations by title, date, or content.
- How to convert your ChatGPT export to Markdown — the full DAG-walk script that produces one .md file per conversation from conversations.json. More reliable than trying to parse the shared link HTML for archival purposes — the source data is already in your export.
- ChatGPT export not working? Eight failure modes and how to recover — troubleshooting guide for when the export email doesn't arrive, the ZIP is partial, or the JSON parser runs out of memory on large exports. Relevant when you're trying to archive conversation content from the export rather than from a shared link.
- Uploaded files in ChatGPT exports — what's included, what's missing — companion page covering the same ephemeral-content problem for files uploaded to conversations (binary content excluded from exports) and DALL-E images (expiring CDN URLs). The same archival urgency applies: content that exists today in ChatGPT-hosted URLs may not resolve in 30 days.
- ChatGPT Memory export — where your memories live in the data download — Memory entries (what OpenAI has inferred about your preferences) are included in the data export via memory.json, unlike shared link UUIDs. This page covers the memory.json schema and the disabled-vs-deleted distinction.
- ChatGPT Team export — differences from Plus, workspace admin flow, and the Compliance API — for team accounts, the workspace export includes the audit log and per-member conversation data. Shared link governance (which members have shared what) is a gap in the admin export; this page covers what the workspace export does and doesn't include for compliance purposes.
- How to extract decisions from your ChatGPT chats — the page that answers the upstream question: given that you have a conversations.json with the full text, how do you pull out the architectural and product decisions buried in it? The extractor approach is more durable than shared links as a decision-documentation strategy.
- The Nygard ADR template — the format for converting a decision recovered from a ChatGPT conversation into a first-class ADR in your repository. A shared link as PR-description reference plus an ADR in doc/decisions/ is the correct two-artifact pattern; a shared link alone is the anti-pattern.
- The open-source extractor — reads ChatGPT conversations.json and surfaces decision-shaped exchanges as structured records; the replacement for shared links as an architectural reasoning artifact.
- ChatGPT web search in conversations.json — what's in the export, what's missing, and how to extract citations — the companion reference for another content category shared links don't capture well: when ChatGPT cites web sources, the shared link renders the assistant's inline citations but not the tether source nodes behind them. The
conversations.jsonexport has both the assistant text and the tether_browsing_display result list with each cited URL. If you're archiving a conversation because it cited important web sources in a decision, the export is more complete than the shared link.