Topic: AI chat export
Perplexity Spaces Export — What Team Workspace Data Is Recoverable (2026)
Perplexity Spaces is the collaborative workspace feature that lets teams share a system prompt, upload context files, and run research threads together. It is where teams do their highest-stakes AI research — the "what database should we use for the new service?" threads run with a shared context file of the current architecture. And it has no export path. Not a limited export path like Gemini's HTML-only Takeout — no export path at all, for the Space configuration, the uploaded files, or the threads grouped by Space. This page documents exactly what is stored, what is accessible, what is lost on account changes, and what the GDPR fallback actually produces.
TL;DR
Perplexity Spaces has no native export. Space Instructions (the system prompt) are readable in the Space settings UI but not downloadable as a file. Uploaded context files cannot be downloaded from the Space after upload — save originals before uploading. Thread content is accessible per-thread in the Library UI but cannot be batch-exported. Team attribution (who asked what) is visible in shared Spaces but is not preserved in any export path, including GDPR requests. Downgrade from Pro = Space UI access lost; retention policy post-downgrade is undocumented. For any decision-quality reasoning produced in a Spaces thread: capture it manually at the end of the session — the reasoning is unrecoverable from any export path once the session is closed and attribution is lost.
What Perplexity Spaces is
Perplexity Spaces (launched mid-2024, available on Pro and Team plans) is a collaborative AI workspace. Each Space has four components:
- Space Instructions — A system-prompt equivalent: a text block that tells Perplexity how to behave in this Space. Examples: "You are a technical advisor for a fintech startup. Focus on regulatory compliance when evaluating technology choices." or "Respond as a competitive intelligence analyst. Always cite sources and flag uncertainty."
- Uploaded context files — Documents Perplexity reads alongside its web search when answering questions in this Space. A team might upload their current architecture diagram, a product spec, or a list of technology constraints. Perplexity uses these as additional context, not as the sole source — web search still runs alongside them.
- Team members — Other Perplexity Pro accounts invited to the Space. In shared mode, all members can see and continue each other's threads. In personal mode, threads are isolated per member but the Space Instructions and uploaded files apply to everyone.
- Threads — The research conversations that happen within the Space. These are standard Perplexity conversations (question + citations + follow-ups) but scoped to the Space context. They appear in the Space's shared thread list (in shared mode) or each member's personal Library (in personal mode).
Spaces is positioned as Perplexity's answer to Claude Projects and ChatGPT Projects — a persistent shared context for recurring research workflows. The key operational difference from the other platforms is that Perplexity is AI-augmented search, not an AI assistant. Space threads typically look like: "What are the trade-offs of CockroachDB vs TiDB for a distributed fintech workload?" — Perplexity returns a structured answer with inline citations. The decision-value is in the cited evidence and the structured comparison, not in a long reasoning dialogue.
What is stored vs what is recoverable
The gap between "stored by Perplexity" and "recoverable by you" is wider for Spaces than for individual threads.
| Data element | Stored by Perplexity | Recoverable via export | Recovery path |
|---|---|---|---|
| Space name and description | Yes | No | Manual copy from Space settings UI |
| Space Instructions (system prompt) | Yes | No | Manual copy from Space settings → Instructions tab |
| Uploaded context file names + sizes | Yes | No | Visible in Space settings Files tab; files not downloadable |
| Uploaded context file content | Yes (until Space deleted or downgrade) | No | Download from original source before uploading; no recovery from Space |
| Team member list and roles | Yes | No | Manual copy from Space settings Members tab |
| Individual thread content (questions + answers) | Yes | Partially (per-thread copy-paste only) | Open thread in Library → Select all → Copy; or Share link (same caveats as personal threads) |
| Cited URLs within threads | Yes (inline in thread) | Partially (per-thread manual copy) | Visible in thread view; no structured URL extract path |
| Thread attribution (who asked what) | Yes (in shared Space UI) | No | Screenshot or manual note at session time; lost in any export path |
| Thread Space attribution (which Space a thread belongs to) | Yes | No | GDPR response strips Space context; threads appear as personal history |
The most important row: uploaded context file content. Perplexity does not provide a path to download files you uploaded to a Space. Once uploaded, the only copy Perplexity exposes is the one it uses for inference — you cannot get it back as a downloadable file. This is not a deliberate restriction; the Perplexity UI simply has no "download Space files" button. The practical consequence: before uploading any file to a Space, verify you have a local copy elsewhere. If your architecture diagram only exists inside a Perplexity Space and that Space is deleted or becomes inaccessible, the file is gone.
The GDPR data request path
As with personal Perplexity threads (covered in the Perplexity conversation export guide), the only full-account data recovery path is a GDPR Article 15 (access) or Article 20 (portability) request submitted to privacy@perplexity.ai. Perplexity is subject to GDPR as a processor of EU personal data regardless of where you are located, because it receives queries that may contain personal data.
What a GDPR response from Perplexity typically contains based on user reports as of 2026:
- Account metadata: name, email, account creation date, plan tier, billing history
- Partial query logs: a subset of your recent queries (not necessarily complete history), sometimes in a CSV format
- No Space configuration data (Instructions, file manifest, member list)
- No thread content in structured format — thread text may appear in query logs but without conversation structure, citations, or Space attribution
The waiting period for GDPR responses can be up to 30 days (Recital 59, GDPR). If you need Spaces data for a time-sensitive reason (team offboarding, project handoff, compliance audit), the per-thread manual copy-paste path is faster and more complete than the GDPR fallback. Start the GDPR request regardless as a parallel track, but do not wait for it.
Space Instructions recovery
The Space Instructions are visible in the Space settings → Instructions tab. This is a plain-text field in the UI; it is not hidden or obfuscated. The recovery procedure is manual: open the Space, open Settings, copy the full Instructions text, paste into a local document. There is no "Export as file" option.
For teams that invest significant effort in Space Instructions — a carefully calibrated system prompt that took multiple iterations to get right — the recommended practice is to maintain the canonical version of the Instructions in a version-controlled document outside Perplexity, and paste it into the Space when updating. This makes the Space Instructions a deployment artifact (what's currently active in the Space) rather than the source of truth. If the Space becomes inaccessible, the source-of-truth document still exists.
This same pattern applies to Claude Projects (custom instructions), ChatGPT Projects (custom instructions), and Custom GPT system prompts: the AI product stores what's active, but the source of truth should live somewhere you control. Perplexity Spaces makes this more urgent than the other platforms because there is no structured export path to recover from.
Uploaded files: the one-way door
Files uploaded to a Perplexity Space pass through a one-way door. Perplexity processes the content for retrieval-augmented generation — it indexes the file so that relevant passages surface when a Space thread asks a question that the file could answer. The processing does not preserve the file as a downloadable artifact. From the Perplexity UI, you can see the file name and size in the Space settings Files tab, and you can delete the file. You cannot download it.
Contrast with ChatGPT Projects (where uploaded files can be downloaded from the Project's Files section) and Claude Projects (where Project Knowledge file names are in the export but binaries are not — you can at least verify what was uploaded, even if you cannot recover the content). Perplexity Spaces provides less visibility than either.
The types of files teams typically upload to Perplexity Spaces — architecture diagrams, product specs, competitive analyses, regulatory documents — are precisely the documents that support decision-making. If those documents exist only in the Space, the Space's inaccessibility takes both the research artifact and the supporting document simultaneously. Keep originals outside the Space.
Team attribution: what disappears
In a shared Perplexity Space, the thread UI shows which team member started a thread and (in multi-turn threads) who asked each follow-up. This attribution is a UI feature — it is displayed from the Space's server-side record of which account made each API call. It is not exported, not included in GDPR responses, and not preserved in share links.
For teams where attribution matters — compliance contexts where you need to know who requested specific AI-assisted research, or onboarding contexts where you want to see which team member worked through a particular technical question — the only way to preserve attribution is to record it manually at session time. A simple format: paste the thread URL plus the team member's name and date into a shared log. The thread URL is stable for as long as the Space exists and the member who created it has an active account.
This is meaningfully different from ChatGPT Team and Claude Team workspace exports, both of which preserve per-conversation attribution (ChatGPT Team: created_by_user_id field joinable against members.json; Claude Team: created_by_uuid field). Perplexity Spaces provides no equivalent in any export path.
Platform comparison: team workspace export coverage
| Platform | Workspace type | Config export (system prompt, instructions) | File export (uploaded context) | Thread export (batch) | Attribution in export |
|---|---|---|---|---|---|
| ChatGPT Team | Projects | Yes (custom_instructions in projects.json) | Manifest only (filenames, no content) | Yes (workspace ZIP via admin) | Yes (created_by_user_id) |
| Claude Team | Projects | Yes (project.json system prompt field) | Manifest only (knowledge base filenames) | Yes (workspace ZIP via admin DSAR) | Yes (created_by_uuid) |
| Perplexity Spaces | Spaces | No (UI-only copy-paste) | No (no download path) | No (per-thread manual only) | No (UI-only, lost in any export) |
| Gemini for Google Workspace | Gems (custom agents) | No (Gem configurations not in Vault export) | No (file binaries not in Vault export) | Yes (Google Vault MBOX, admin-only) | Partial (email-threaded attribution) |
Perplexity Spaces is the weakest of the four on every export dimension. This is not a product oversight — it reflects Perplexity's legal positioning as an AI search engine rather than a personal AI assistant, which changes what GDPR Article 20 data portability obligations apply and how conversation history is classified. The practical consequence is that Perplexity Spaces requires more disciplined manual capture than any other team AI workspace.
The decision-capture workflow for Spaces research
Teams use Perplexity Spaces most productively for the research phase that precedes a decision — the structured investigation of trade-offs, vendor options, regulatory constraints, or competitive landscape before a technical or product call is made. The decision itself is often made in a separate ChatGPT or Claude conversation where the reasoning is worked through, or in a team meeting. The Spaces research thread is the evidence gathering.
The export gap means: at the end of a Spaces research thread that produced a clear recommendation or surfaced a decisive piece of evidence, extract that into a decision record before closing the tab. The minimum capture:
- The thread URL (stable while the Space and account exist)
- The question that triggered the key finding (verbatim from the thread)
- The key finding itself (the recommendation or decisive fact), with one or two of the cited URLs
- The team member who ran the thread (from the UI attribution, before it's lost)
- The date
This is the Context section of an ADR, pre-filled from Spaces research. If the team subsequently makes an architecture decision based on this research, the captured Spaces output becomes the primary source for the ADR's Context and the cited evidence in the Consequences section. The thread URL serves as the "RFC" pointer — the deliberation record that explains why the Context section reads the way it does.
For teams where the decision conversation itself happens in ChatGPT or Claude (not Perplexity), the WhyChose extractor surfaces those decisions from the ChatGPT or Claude export automatically. Perplexity Spaces research that fed the decision conversation is captured at the point of the decision, not from the Spaces thread — which is why the manual capture step above matters: by the time you run the extractor on the ChatGPT export, the Spaces context that informed the decision is only preserved if someone wrote it down.
Related questions
Does Perplexity Spaces data get included in GDPR data access requests?
Partially, and the attribution is lost. A GDPR Article 15 data access request to Perplexity (privacy@perplexity.ai) typically returns account-level metadata, partial query logs, and billing records. Individual thread content from Spaces may be included in the same format as personal threads — but the Space attribution (which Space the thread belongs to, which team members contributed to it, what Space Instructions were active) is not preserved in the GDPR response. Threads from Spaces appear as generic research threads with no indication they originated in a collaborative workspace. The Space configuration (name, Instructions, file manifest) may not be included at all, and the waiting period for GDPR responses can be up to 30 days. If you need Spaces data for a compliance or handoff reason, the per-thread manual copy-path is faster and more complete than waiting for a GDPR response.
Is there a Perplexity API path to retrieve Spaces thread history?
No. The Perplexity API (available on Pro plans) is a stateless inference endpoint — it accepts a query and returns a response with citations, but it stores nothing server-side and has no endpoints for listing threads, retrieving past conversations, or querying Space content. This is the same architectural position as the OpenAI Playground and the Anthropic API: a stateless API for running queries, not a product with server-side conversation history. The Spaces threads you see in the Perplexity web UI are stored in Perplexity's backend database and are accessible through the UI — they are not accessible via the public API. If you need to retrieve thread content programmatically, the only path is the GDPR Article 15 request, and even that does not guarantee structured output with Space attribution intact.
What happens to Spaces data if I downgrade from Perplexity Pro?
Spaces is a Pro-tier feature. On downgrade to the free tier, the Spaces you created or were a member of are no longer accessible through the UI. Perplexity's retention policy after a downgrade is not publicly documented as of 2026 — which means there is no guarantee that the Space configuration, uploaded files, or thread content is preserved on Perplexity's infrastructure if you later re-upgrade. The practical answer is to export everything you need from a Space before downgrading: copy-paste the Space Instructions from the Space settings, download each uploaded file from its original source (not from the Space — Perplexity does not provide a download-from-Space path), and copy-paste any thread content you need to keep. Treating downgrade as an account closure for the purposes of data recovery is the conservative and correct approach.
Can all team members see each other's threads within a Perplexity Space?
This depends on how the Space was configured and which plan tier your team is on. Perplexity Spaces can be set to shared mode (all members see all threads) or personal mode (each member's threads are private to them). In shared mode, threads created by any team member appear in the Space's shared thread list. In personal mode, threads are isolated per member but the Space Instructions and uploaded files apply to everyone. The Space creator sets this at creation time; it can be changed in Space settings. For the purposes of export and data recovery, even shared-mode threads are not collectively exportable — each thread is accessed individually through the UI, and attribution (who started the thread, which member contributed follow-up queries) is visible in the shared thread UI but is not preserved in any export path, including GDPR requests.
Further reading
- Perplexity conversation export — how to save your AI research history (2026) — the base layer: individual thread export, the GDPR path for personal Perplexity data, and why Perplexity's legal positioning as an AI search engine affects what data portability obligations apply.
- ChatGPT Projects export — custom instructions, files, and conversation routing — the best-case comparison for team workspace export: ChatGPT Projects includes custom instructions in the export and threads are batch-exportable with Space attribution via the workspace admin flow.
- How to export a Claude Project (system prompt, knowledge base, all conversations) — the symmetric Claude side: system prompt is in the export, Knowledge Base file names are in the manifest (no binaries), all project conversations are included, created_by_uuid attribution is preserved.
- Gemini Workspace export — Google Vault, admin console, and enterprise data portability — the Google-side comparison: Gem configurations are also not exported (same gap as Perplexity Spaces Instructions), but conversation content is accessible via Google Vault in MBOX format for admin-initiated exports.
- How to extract decisions from your ChatGPT chats — for teams whose decision conversations happen in ChatGPT after Perplexity Spaces research: the structured extraction recipe that surfaces the decisions from the ChatGPT export, for use as ADR Context material.
- Gemini Deep Research export — reports, citations, and what appears in Google Takeout — the most direct comparison to Perplexity Spaces for research-heavy teams: Gemini Deep Research also produces multi-page reports with source citations, but with significantly better export coverage (full report text in Google Takeout, versus Perplexity's zero-batch-export story for Spaces). The comparison table on that page shows Gemini Deep Research, Perplexity, and ChatGPT Browse side by side across export coverage, citation structure, and decision-capture implications.