Guides › Chat-history extraction
GitHub Copilot Chat Export — Why There Isn't One, and Where Your History Actually Lives
GitHub Copilot Chat stores conversation history in VS Code's local workspace storage — not in any GitHub server. No user-facing export button exists, and GitHub's account data archive does not include Copilot Chat conversations. For engineering teams making architecture decisions in their IDE, this is the most invisible data-portability gap in the AI-tool ecosystem.
TL;DR
GitHub Copilot Chat conversations persist locally in VS Code's workspace storage (~/.config/Code/User/workspaceStorage/<hash>/ on Linux; similar paths on macOS and Windows). They are not synced to GitHub for personal or Teams plans. GitHub's account data export does not include Copilot Chat history. GitHub Copilot for Business and Enterprise stores usage telemetry (request counts, acceptance rates) centrally — but not conversation content. The practical consequence: Copilot Chat decisions are the least recoverable of any major AI platform. Manual copy-paste at session time is the only reliable capture path.
Disambiguation: which GitHub Copilot product?
GitHub has shipped several products under the Copilot brand. This page covers GitHub Copilot Chat — the conversational AI interface embedded in VS Code (via the GitHub Copilot Chat extension), JetBrains IDEs, and Visual Studio. Copilot Chat is a turn-by-turn chat interface where you can ask questions about code, get explanations, plan refactors, and work through design decisions in the context of your open workspace.
This page does not cover:
- GitHub Copilot inline suggestions (the code-completion feature that appears as ghost text as you type — these are not conversations and produce no conversation history).
- Copilot in GitHub.com (AI-generated PR summaries, code review suggestions in the pull request UI — stored as part of the PR, not as a chat session).
- Copilot Workspace (the planning and multi-file editing experience on github.com — separate product, separate data model).
- GitHub Models / GitHub Copilot API (direct API access, stateless like the Anthropic and OpenAI APIs).
Microsoft Copilot (consumer and M365) is a separate product from GitHub Copilot despite the shared "Copilot" branding. Microsoft Copilot at copilot.microsoft.com and in Microsoft 365 apps is covered in its own guide — it has a different storage model (server-side for consumer, Purview for enterprise) and different access paths than GitHub Copilot Chat's local-only model.
Where GitHub Copilot Chat history is stored
When you use GitHub Copilot Chat in VS Code, the extension stores conversation history in VS Code's workspace storage — a per-workspace SQLite or IndexedDB store managed by VS Code itself. The workspace hash is a deterministic function of the workspace folder path (typically a SHA-256 of the absolute path), so the same workspace folder always maps to the same storage directory.
Storage paths by OS
| OS | VS Code workspace storage path |
|---|---|
| macOS | ~/Library/Application Support/Code/User/workspaceStorage/<hash>/ |
| Linux | ~/.config/Code/User/workspaceStorage/<hash>/ |
| Windows | %APPDATA%\Code\User\workspaceStorage\<hash>\ |
Within the workspace storage directory, GitHub Copilot Chat stores its state in a subdirectory keyed to the extension identifier (github.copilot-chat). The internal format is not a documented API — it is an implementation detail of the extension that can change across versions. The extension uses VS Code's Memento (key-value) and file storage APIs, which typically produce JSON files or SQLite databases in the workspace storage path.
Because the format is undocumented and subject to change, there is no reliable tool for parsing VS Code's Copilot Chat storage as of 2026. The extension itself reads the history for display in the Chat panel; outside the extension, the format is opaque.
What is and isn't synced
VS Code Settings Sync (sign-in with GitHub or Microsoft account) synchronizes across devices:
- Settings (
settings.json) - Keybindings
- Extensions (list of installed extensions)
- Snippets
- UI state (panel positions, theme)
VS Code Settings Sync does not synchronize workspace storage. Copilot Chat conversation history is workspace-local, not account-synced. An engineer using GitHub Copilot on two different machines — a laptop and a desktop — has separate conversation histories on each.
What IS and ISN'T stored
| Data element | Stored? | Where | User-accessible? |
|---|---|---|---|
| Chat conversation text (prompts + responses) | Yes | VS Code workspace storage, local device | Via Copilot Chat panel; no export API |
| Code context sent with prompt (file snippets) | Not separately persisted | Embedded in conversation text if the response referenced it | Via conversation text only |
| Inline code completions (ghost text) | No | Not stored as conversation | Not stored |
| Conversation history across workspaces | No shared history | Each workspace has isolated storage | Per-workspace only |
| Conversation history across devices | No | No cloud sync for Copilot Chat | Device-local only |
| Usage telemetry (request counts, acceptance rates) | Yes | GitHub's servers (for Business/Enterprise) | Via org admin dashboard; aggregate metrics only |
| Conversation content (GitHub Enterprise) | No | Not transmitted to GitHub servers per GitHub's privacy policy | Not available to admins |
What is never stored or accessible
- Any conversation from a different workspace. The auth service workspace and the payments service workspace each have their own isolated Copilot Chat history. There is no cross-workspace conversation view.
- Conversations after VS Code workspace storage is cleared. If you delete VS Code's workspace storage directory, reinstall VS Code, or the extension clears its storage during an update, conversation history prior to that point is not recoverable.
- Inline suggestions you accepted or rejected. These are not stored as conversation history — only explicit Chat panel interactions produce persistent history.
GitHub Copilot for Business and Enterprise
GitHub Copilot for Business and Enterprise plans introduce organization-level usage reporting, but the key data-portability facts are the same as the personal plan: conversation content is stored locally, not in GitHub's servers.
What GitHub collects at the organization level
Organization admins on Copilot for Business and Enterprise can view aggregate usage metrics via the GitHub organization settings:
- Active Copilot users (count and list by GitHub username)
- Copilot Chat interaction count (turn-level, not session-level; not per-user in all views)
- Inline suggestion acceptance rate (accepted suggestions / total suggestions shown)
- IDE breakdown (VS Code, JetBrains, Visual Studio, Vim, Neovim)
- Language breakdown (which programming languages received Copilot suggestions)
These are aggregate metrics for understanding adoption and ROI. They do not include conversation transcripts, prompt text, code context sent with prompts, or response content.
What GitHub's privacy policy says about Enterprise
GitHub's Copilot for Business and Enterprise privacy documentation states that customer code (prompts and surrounding code context) is not retained by GitHub and is not used to train foundation models for these tiers. The processing happens in real time and the content is not logged to a persistent store accessible through GitHub's services. This is the privacy trade-off: better data protection for organizations, but also means there is no GitHub-side store to access for conversation recovery.
The practical consequence for Enterprise admins: if an engineer on a Copilot Enterprise plan asks "can you retrieve my Copilot Chat conversations from last month," the answer is no — not because of access controls, but because GitHub does not store them.
GitHub's account data archive
GitHub provides an account data export at github.com → Settings → Archives → Export account data. The ZIP archive contains:
- Repositories you own (metadata, not code unless mirrored)
- Pull requests (all PRs you created, with comments)
- Issues (all issues you created)
- Commit activity attribution
- Stars, follows, organization memberships
- SSH keys, GPG keys, OAuth apps
- Account profile metadata
The archive does not contain:
- GitHub Copilot Chat conversation history
- GitHub Copilot inline suggestion history
- GitHub Copilot Workspace session history
- Code review AI suggestions on PRs
This is consistent with the local-storage model: GitHub doesn't include Copilot Chat history in the archive because it doesn't have it. The conversations live on your device.
GDPR and privacy request paths
If you submit a GDPR Article 15 (right of access) or Article 20 (data portability) request to GitHub via their privacy portal, the response will include personal data GitHub holds about your account — profile information, activity records, usage telemetry for Copilot (if on a Business/Enterprise plan). It will not include Copilot Chat conversation content because GitHub does not hold that data for personal and Teams plans, and for Enterprise plans, GitHub's Copilot data handling is designed to avoid persistent storage of conversation content.
GitHub's GDPR contact channel is github.com/privacy/personal-data. The response typically takes up to 30 days. For Copilot Chat specifically, a GDPR request is unlikely to yield conversation content — it's more useful for account metadata and the aggregate usage records GitHub holds at the organization level.
Platform comparison: export capability
| Platform | Conversations stored? | User-facing export? | Cloud sync / server-side? | Enterprise admin access to content? |
|---|---|---|---|---|
| ChatGPT (OpenAI) | Yes | Yes (conversations.json ZIP) | Yes (OpenAI servers) | Team: Compliance API; Enterprise: workspace ZIP |
| Claude (Anthropic) | Yes | Yes (conversations.json ZIP) | Yes (Anthropic servers) | Team: DSAR path; workspace admin export |
| Microsoft Copilot (consumer) | Yes | No (privacy dashboard only) | Yes (Microsoft servers) | N/A (consumer product) |
| Microsoft 365 Copilot | Yes | No (Purview admin path) | Yes (Microsoft 365 tenant) | Yes — Purview eDiscovery (PST format) |
| GitHub Copilot Chat (personal/Teams) | Yes — locally | No | No — local device only | No — content not transmitted to GitHub |
| GitHub Copilot Chat (Enterprise) | Yes — locally | No | No — content not transmitted to GitHub | No — GitHub has aggregate telemetry only |
| OpenAI Playground / Anthropic API | No — stateless | N/A | No — no server-side session storage | N/A |
The key contrast: GitHub Copilot Chat is the only major AI coding tool where conversation history is stored only on the engineer's local device. ChatGPT and Claude store conversations server-side and provide structured exports. Microsoft Copilot stores conversations server-side (with access complexity). GitHub Copilot's local-only model is the best privacy model for conversation content — it's also the worst for data portability and disaster recovery.
Why GitHub Copilot Chat decisions matter most
GitHub Copilot Chat is the AI session with the richest code context. When an engineer asks "should I use a cursor-based or offset-based pagination here?" in Copilot Chat, the model can see the actual schema, the query patterns in the file, the ORM layer in the project — context that a ChatGPT conversation about the same question lacks. The reasoning produced by Copilot Chat is therefore more code-grounded, more specific, and often more architecturally significant than the same discussion would be in a general-purpose AI chat.
This makes Copilot Chat decisions particularly worth capturing — and the local-storage-only model makes them particularly easy to lose. An engineer who clears VS Code workspace storage during a system cleanup loses months of decision reasoning that they probably didn't know was stored there.
The asymmetry: the decisions made in ChatGPT and Claude are recoverable from the structured export, automatically extractable by a tool like WhyChose, and searchable after the fact. The decisions made in GitHub Copilot Chat — which are often the most implementation-specific and technically grounded decisions in the engineering process — are recoverable only if the engineer deliberately copied the relevant exchange at session time.
Decision-capture workflow for Copilot Chat
The minimum capture for any Copilot Chat exchange where a decision was made:
- The question you asked, as typed (the prompt)
- The full response — do not paraphrase; the original model output includes the trade-off framing, the alternative it rejected, and the specific constraints it cited from your code context
- The workspace and file that were open — this establishes the decision's scope (which service, which layer, which PR context)
- The date — Copilot Chat does not always display timestamps in a copy-pasteable form; add it manually
This capture becomes the raw material for an ADR's Context section (the code situation that prompted the question), Decision section (the direction the model recommended and you accepted), and Consequences section (the trade-offs the model named explicitly).
Practical convention: at the end of any Copilot Chat session that produced a durable decision, paste the key exchange into a DECISIONS.md file in the relevant service directory. This is not the ADR — it's the pre-ADR capture buffer. Review it weekly; promote exchanges that pass the four-question threshold to actual ADRs. The remaining exchanges sit in the buffer as informal decision log entries, searchable when the "why did we do it this way?" question comes up in a code review.
For ChatGPT and Claude conversations where the same design discussions happen (and which you export periodically), the WhyChose extractor automates this step — identifying decision-shaped exchanges and emitting ADR-ready records. The workflow for Copilot Chat is deliberately manual because there is no structured export to automate from.
Related questions
Is GitHub Copilot Chat history saved anywhere?
Yes — locally, in VS Code's workspace storage on your device. GitHub Copilot Chat conversations persist across VS Code sessions within a given workspace. The storage is local to your device; there is no cloud sync for personal or Teams plans. If you reinstall VS Code, switch devices, or clear workspace storage, the conversation history is not recoverable. GitHub Copilot for Business and Enterprise plans have usage telemetry stored on GitHub's servers (request counts, acceptance rates), but conversation content is not part of that telemetry — GitHub's privacy documentation states it is not retained server-side for these tiers.
Does GitHub's data export include Copilot Chat conversations?
No. GitHub's account data archive (github.com → Settings → Archives → Export account data) contains repositories, pull requests, issues, commits, stars, SSH keys, and account metadata. It does not include GitHub Copilot Chat conversation history. For personal and Teams plans, Copilot Chat conversations are stored locally on your device in VS Code's workspace storage — GitHub doesn't have them to include in an export. For Enterprise plans, GitHub stores aggregate usage telemetry at the organization level, but conversation content is not part of that data.
Can my GitHub Enterprise admin see my Copilot Chat conversations?
No, not the conversation content. Copilot for Business and Enterprise organization admins can see aggregate metrics: number of Copilot users, acceptance rate of inline suggestions, chat interaction count, IDE breakdown. This usage telemetry is for billing and adoption tracking. GitHub's privacy documentation for Copilot for Business states that chat prompt data is not retained by GitHub for Enterprise customers and is not available to organization admins. The conversation lives in VS Code's workspace storage on the engineer's device — GitHub does not have it.
How do I save a GitHub Copilot Chat conversation before it's gone?
Manual copy-paste at session time is the only reliable path. Open the Copilot Chat panel in VS Code, select the relevant exchange, and copy it to a note, decision log entry, or ADR draft. For a decision-bearing conversation, capture: the key question you asked, the full response including trade-off comparison, and any code snippets that anchor the reasoning. The date is important — add it manually since the Chat panel does not always display it in copyable form. For ChatGPT and Claude conversations where architecture decisions also happen, the WhyChose extractor automates extraction from the structured conversation export — the deliberate at-the-time capture is only required for Copilot Chat specifically.
Further reading
- Microsoft Copilot export — how to retrieve conversation history (2026) — the closest analog product and the guide this page explicitly differentiates from: Microsoft Copilot at copilot.microsoft.com and in Microsoft 365 stores conversations server-side (history sidebar for consumer, Purview for M365 enterprise) — a different model from GitHub Copilot Chat's local-only storage. Microsoft 365 Copilot decisions are often better-reasoned than ChatGPT decisions (Copilot has M365 context) but equally hard to export.
- ChatGPT Team export — differences from Plus, workspace admin flow, and the Compliance API — the OpenAI enterprise export story: Compliance API for Enterprise, workspace ZIP for Team. The contrast to GitHub Copilot Enterprise (no equivalent path for conversation content) is instructive for teams choosing between AI platforms on data-portability grounds.
- Claude Team workspace export — admin DSAR path, member scope, and Project isolation — the Anthropic enterprise export: workspace ZIP via DSAR with member attribution. Also a server-side model with structured export, unlike GitHub Copilot's local-only model.
- How to extract decisions from your ChatGPT chats — for decisions made in ChatGPT alongside Copilot Chat: the structured extraction recipe that automates the decision-capture step for conversations that do have a structured export.
- How to extract decisions from your Claude conversations — the symmetric Anthropic-side extraction guide. For engineering teams using Claude as a design-thinking partner alongside GitHub Copilot Chat for implementation, the two tools have opposite portability profiles: Claude exports recover automatically; Copilot Chat requires manual capture.
- How to export your ChatGPT history (2026 guide) — the export path that GitHub Copilot Chat lacks: a self-service ZIP download with complete conversation history in structured JSON format. If design decisions are happening in both ChatGPT and Copilot Chat, the ChatGPT side is always recoverable from the export; the Copilot Chat side requires deliberate capture at session time.
- Cursor AI chat export — what's stored, what's lost, and how to capture decisions — Cursor AI has the same fundamental architecture as GitHub Copilot Chat: VS Code-based, API-routed, no server-side conversation store, no native export. The Cursor page covers the local storage path (state.vscdb in workspaceStorage, unstable schema), the GDPR data request story (account metadata only, no transcripts), and the redirect strategy — using Claude.ai or ChatGPT for architecture deliberation while using Cursor for implementation. The comparison table covers six AI IDE tools (Cursor, GitHub Copilot, Windsurf, Zed AI, Claude.ai, ChatGPT) across the same export dimensions.
- Windsurf AI chat export — what Codeium stores, what's lost, and how to capture decisions — the third entry completing the AI IDE no-export cluster. Windsurf (Codeium) differs architecturally from both Cursor and GitHub Copilot Chat: Codeium has its own model infrastructure and stores partial session metadata server-side, unlike Cursor's pure API-routing and GitHub Copilot's local-only model. But the user-facing export story is identical to the other two — no conversation transcript export exists. The page covers Codeium's data model, the Cascade vs Cursor Composer comparison, and the same redirect-to-Claude.ai/ChatGPT decision-capture strategy used across all three AI IDEs.
- Zed AI chat export — what Zed stores, what's lost, and how to capture decisions — the fourth and final entry in the AI IDE no-export cluster. Zed is a Rust-native code editor (not a VS Code fork) with the most direct-API-routing architecture of the four: AI Panel requests go directly from the Zed client to model provider APIs without any Zed Industries intermediary server — contrasting with GitHub Copilot's extension-model path, Cursor's Anysphere API proxy, and Windsurf's Codeium model infrastructure. No Zed-side conversation storage at all, same zero-export outcome.