You uploaded a 40-page contract to ChatGPT this morning, asked for a compliance summary, and closed your laptop after checking the draft. Hours later, you open the conversation again, click the PDF preview to re-verify a clause, and there it is: a red notice that reads, "This file is no longer available. Please re-upload the file to continue."
Annoying? Absolutely. Confusing? Even more so, because the conversation thread is still right there in front of you.
If you've worked with ChatGPT's file features for any real length of time, you know this exact scene. And it always leads to the same question: why do ChatGPT files expire while the chat that contains them remains visible?
Here's the short version: uploaded files don't live in a personal cloud drive tied to your account. ChatGPT places them into a temporary, conversation-scoped workspace, and that workspace can be cleaned up at any moment. Expiration is not a bug you triggered; it's a deliberate trade-off among privacy, data retention policy, and server load. Your local PDF is fine. The copy ChatGPT needed to read is gone.
In this guide, I'll walk you through the mechanics, the policy, the time limits you can realistically expect, and the fixes that keep file expiration from wrecking your workflow.
ChatGPT File Expiration Policy: What Does "File Expired" Mean?
When ChatGPT tells you a file has expired, it means the model can no longer reach the working copy it was using. The document itself isn't corrupt. Nothing happened to the original on your laptop. A server-side copy, stored in an isolated environment the model could read and process, was deleted or rotated out.
I like to compare it to handing a printed report to a contractor who's sitting at a shared desk. While you're actively talking with them, they can grab the report, annotate it, and answer questions. When the contractor's shift ends or the desk gets reassigned, the copy is tossed. The original is still in your bag, but the person who needs to work with it no longer has access.
Much of the confusion I see in actual troubleshooting sessions comes down to two things: mixing up file expiration with link expiration, and trusting the preview card more than you should.
Expired file vs. expired shared link: why users mix them up
ChatGPT creates more than one kind of temporary object when you work with files. An uploaded file sits inside a sandbox on OpenAI's servers. A shared conversation link, meanwhile, is a separate URL protected by session tokens. Those two things have independent lifecycles, yet users constantly treat them as one problem.
When you share a conversation, ChatGPT mints a temporary access link that lets someone else view that chat. If that link stops working, you'll see an error that sounds a lot like the file-expired message. But the underlying file in your account might still be available. Conversely, an uploaded file can expire because of file attachment expiration rules even while an old share link still opens for someone who clicked it earlier — though attachments in that shared view may show as dead.
| Symptom | What it looks like | What actually happened | Working fix |
|---|---|---|---|
| Attachment card says "file expired" | You can't open or analyze the uploaded document | The server-side working copy was cleaned up | Re-upload the original file |
| Shared link returns an error | The entire conversation view won't load | The temporary access link expired, or the chat was deleted/cleaned | Generate a new share link |
| Both fail at the same time | No path to the content at all | Sandbox removal plus link expiration happened together | Re-upload the file, then create a fresh share link |
| The fastest way to tell which one you're dealing with: open the chat directly from your own ChatGPT sidebar. If the conversation loads but the attachment is dead, it's file expiration. If the conversation won't load even for you, it's probably a link or account-level problem. |
The preview is still there, so why is the file inaccessible?
This is the part that trips up almost everyone. "But the file preview is right there," they say. "Why can't ChatGPT read it?"
Because the preview card is only a cached thumbnail. It's the interface's way of remembering that an upload happened. That little icon with the file name and page count is not the file itself. It doesn't keep the underlying data alive, and its presence doesn't mean the model can still access the contents.
The real uploaded file lives inside a server-side file storage container that is deliberately temporary. When ChatGPT performs cleanup on that container, the preview card stays in the message history because deleting it would alter the visible conversation log. So you end up with a ghost: the chat remembers the file, the preview shows it, and yet the assistant can't touch a single byte of it.
This also explains a related myth. Many people assume that deleting a conversation deletes the files, or that expiring a file deletes the conversation. Neither is exactly true. Conversation history and file attachment expiration are managed separately. You can keep a chat for years with its previews intact, but every link to the actual file content may be long gone.
How Long Before ChatGPT Files Expire? Plan-by-Plan Time Limits
Now for the question everyone actually wants answered: how long do you have?
I'll be straight with you: OpenAI does not publish a single universal expiration number for consumer ChatGPT uploads. There's no official table that says "Free expires after 2 hours, Plus after 12." The answer depends heavily on where the file was uploaded, which plan you're on, and what the platform is doing at that moment. After tracking these behaviors across multiple accounts, I can give you a practical picture even if I can't give you a precise guarantee.
Context files, sandbox files, and persistent files are not the same
Not all ChatGPT uploads use the same storage system. This might be the most important distinction in the entire conversation about expiration.
Context files. When you attach a document to an active chat and ask questions about it, ChatGPT reads the relevant content into the model's context. As long as that context stays alive, the assistant can reference and quote the material. But context isn't permanent. Community observations — and my own informal tests — suggest that an idle context attachment can become unavailable after a few hours; reports often point to roughly 3 hours before cleanup kicks in [需核实]. OpenAI doesn't document this figure, so treat it as a rule of thumb, not a contract.
Sandbox files. When you ask ChatGPT to analyze data, generate a chart, or run code, the work happens inside a sandboxed execution environment. That environment has its own time-to-live. If the session stays inactive too long, or if the environment resets, the files inside it evaporate. This is why a generated output file might be available for download one minute and unreachable the next.
Persistent files. Uploads placed into ChatGPT's Files area or a Project are intended for longer-term reuse. They're separate from the one-off attachments that die with a chat session. If your workflow depends on reference material across multiple sessions, this is the layer you should be using. The exact longevity still depends on your account tier and OpenAI's current product behavior.
| Storage type | Where files live | Typical observed lifetime | Expiration risk |
|---|---|---|---|
| Context attachment | Temporary chat context | A few hours if idle [需核实] | High |
| Sandbox working file | Isolated sandbox environment | Minutes to hours | High |
| Persistent file | Files or Projects library | Days, weeks, or longer | Low |
| API file | Assistants API vector store | Until explicitly deleted | Very low |
File retention by subscription tier: Free vs. Plus, Team, and Enterprise
Different plans genuinely behave differently when it comes to retention, although you won't find this spelled out in any official policy page.
Free accounts tend to clean up aggressively. When server load spikes, free-tier sandboxes are often the first to be recycled. I've seen free users lose file access after just a few hours of inactivity. That's not a malicious choice; free resources are simply constrained.
Plus and Pro accounts get more breathing room. Files uploaded and used in the same working session typically survive long enough to finish the task. But return to that chat a day later, and the attachment may be gone. Team and Enterprise accounts fall somewhere else entirely: some workspaces configure stricter expiration windows for compliance reasons, and what you experience depends on your organization's settings.
| Plan | Typical observed retention | Best use | How to avoid expiration |
|---|---|---|---|
| Free | Very short; uploads often expire between sessions | Small, one-off tasks | Download outputs immediately; re-upload as needed |
| Plus / Pro | Moderate; usually long enough for same-day work | Active file analysis | Store key files in persistent storage; don't switch models mid-task |
| Team | Workspace-defined | Shared internal projects | Ask your admin about retention defaults |
| Enterprise | Configurable; often strict for compliance | Regulated or sensitive data | Follow workspace storage policies; use approved integrations |
Does ChatGPT delete files after 30 days?
You'll see the 30-day figure repeated in countless threads, and it's usually mangled. The number has a real origin, it just doesn't mean what most people think.
The 30-day reference comes from OpenAI's data retention policy, which describes how long content may be kept in backend systems before permanent deletion. That policy is about internal data handling — including safety monitoring and abuse review — not about how long a file remains accessible in your chat.
There's a gap between product-level expiration and account-level retention. You might upload a file today, see it expire from the chat tomorrow, and then delete that entire conversation a week later. OpenAI's systems may still retain some content associated with that exchange for up to 30 days after deletion [需核实], depending on the policy in effect. None of that means the file was readable or available to you during the retention window.
So when someone asks: "Does ChatGPT auto-delete files after 30 days?" the honest answer is: not usually. Expiration usually comes much sooner. The 30-day line describes what OpenAI's backend may hold after deletion, not what you can access in your sidebar.
Why Does ChatGPT Expire Files After Inactivity? Design Triggers Explained
Once you know that expiration exists, the next question is what pulls the trigger. Part of the answer is hidden in the phrase "after inactivity." ChatGPT doesn't always delete files on a fixed schedule; sometimes it deletes them when you stop interacting. Engineering constraints explain why.
TTL and sandbox cleanup: the engineering reason
Every uploaded file that enters a ChatGPT tool environment gets assigned to a sandbox with a time-to-live — a TTL. Think of a TTL as a countdown timer that starts when the sandbox is created. The timer doesn't care how important your document is. When it reaches zero, the server runs cleanup: the sandbox is dismantled, its storage is freed, and your file's working copy disappears.
This is the same logic that governs temporary access links in many systems. A cloud storage blob might still exist on disk, but if the signed URL that points to it carries a TTL, the link stops working when the timer ends. The file is there; the access path is gone.
In consumer ChatGPT, you can't change that TTL. There's no setting that says "keep my files for 48 hours." Engineers building on the API can manage file lifecycles programmatically, but regular users get whatever default the client applies.
A simplified view of the process:
You upload → ChatGPT assigns a sandbox → TTL starts → inactivity or session reset occurs → server cleans up the container → you see "file expired"
Inactivity, model switching, reopening chats, and app restarts
Several everyday actions accelerate that countdown. Most of them come down to resetting the environment your file lives in.
Long idle periods. You close the browser tab, go to a meeting, and come back three hours later. The container may have been recycled while you were away. ChatGPT doesn't keep every inactive sandbox running forever just because you might return.
Switching model variants. If you start a conversation using one model and then switch to another — say, from a standard model to a reasoning model — the platform often resets the internal tool environment. Files that were attached before the switch can expire on the spot. This one consistently surprises users because the chat itself remains intact.
Reopening old chats. That file from a month ago? The preview will still be there, but the sandbox was probably destroyed days ago. Reopening the conversation doesn't restore it.
Background app restarts. On mobile or desktop, ChatGPT apps sometimes restart in the background. The session is rebuilt, session tokens are refreshed, and the tool state that held your uploaded file is gone. You don't notice anything until you click the attachment and get the error.
Is expiration a bug or a deliberate feature?
Most expiration is deliberate. OpenAI has strong reasons not to store uploaded files permanently inside casual conversations: privacy compliance, security, and system performance all improve when temporary working copies are destroyed regularly. Automatic deletion reduces the risk that your sensitive material lingers on servers longer than necessary.
But some spikes of "file expired immediately after upload" are genuine bugs or platform incidents. On November 15, 2025, for example, OpenAI's status page acknowledged that file uploads to conversations were failing for some users and showing an error indicating the file had expired. That was not normal retention behavior; it was a service incident.
So how do you tell the difference? Simple. If you upload a file and it expires seconds later, that's suspicious and likely platform-related. If you come back to an old chat and the file is expired, that's normal lifecycle behavior.
Fix ChatGPT File Expired Error: Step-by-Step Troubleshooting
When the error appears, your instinct might be to hunt for a buried setting or a recovery command. There isn't one. The path forward is straightforward, and you already have what you need: the original file.
The 30-second fix every user should try first
Re-upload the file. That's it. No prompt will resurrect the old sandbox, but a fresh upload creates a brand-new one.
- In the same conversation, click the attachment icon and upload the file again.
- If the error persists, open a new chat and upload there. A new conversation gives you a clean sandbox and avoids whatever stale state was causing trouble.
- After re-uploading, give the model the context it needs: "I'm continuing from the analysis we did earlier. Using this new copy of the file, please pick up where we left off."
- If you had already generated important responses, copy those outputs into a separate document before re-uploading. That way the work isn't lost even if the input file expires again.
You'll be surprised how often this simple sequence resolves the issue in under a minute.
Fix "file expired immediately after upload" when it looks like a bug
The 30-second fix normally handles files that expired after hours or days. But what about the cases where the upload finished, you blinked, and the file was already marked expired?
I've seen this happen enough times to recognize the usual culprits:
- The model variant changed while the upload was in progress
- The app or browser restarted in the background
- A stale tool state carried over from a previous conversation
- The platform was having an upload-related incident
Try this checklist in order:
| Possible cause | What to do |
|---|---|
| Toggled models during upload | Switch back to the original model, or start a fresh chat |
| Background app restart | Force-quit the app and reopen it |
| Stale browser session | Refresh the page or try an incognito window |
| Platform incident | Check OpenAI's status page and retry in 30–60 minutes |
| If the issue happens across all chats, all files, and multiple browsers, it's most likely not on your end. Check the status page before you spend time clearing caches or reinstalling the app. |
Can you recover an expired ChatGPT file?
No. Once ChatGPT loses access to the temporary working copy, the file cannot be restored from the interface. There is no hidden URL trick, no special prompt, no "file recovery" menu buried in the settings.
What you can still recover:
- The original file from your local device (assuming you still have it)
- A copy stored in ChatGPT's persistent Files or Projects area, if you placed it there
- Any outputs you generated and saved in a separate document
The harsh reality is that re-uploading is the only supported remedy. This is exactly why session hygiene matters — and why you should never upload your only copy of an important file into a chat.
How to Prevent ChatGPT Files From Expiring: Storage Workflows That Work
Rather than treating expiration as an occasional inconvenience to fix, you can design your workflow so it rarely happens. The preventative moves don't take that much effort, but they make a significant difference.
Use persistent storage instead of one-off chat uploads
If you're on ChatGPT Plus, Pro, Team, or Enterprise, take advantage of the Files or Projects areas in the sidebar. A file stored there is not the same as a file dragged into an individual chat. Persistent storage is designed to survive across conversations. When you attach a file from that library to a chat, you're referencing a durable copy rather than uploading a fragile one.
For long-term projects — client research, multi-session report writing, datasets you'll analyze repeatedly — that distinction matters. Don't rely on local temporary uploads for anything you might still need next week.
Session hygiene habits that prevent ChatGPT files expire before download
A few small habits will keep you out of trouble 90 percent of the time:
- Download important generated output immediately after it appears. Don't leave it in the chat waiting.
- Avoid switching model variants mid-task. Finish the current file interaction before you change models.
- Keep long sessions active with an occasional prompt. Idle sessions are prime cleanup targets.
- Break oversized files into smaller pieces. Big uploads are more likely to hit processing limits or trigger cleanup during high load.
- Store the original file in a backup folder before you upload it anywhere.
None of these require special software. They just require treating ChatGPT chat attachments as the temporary conveniences they actually are.
Developers: use the API with persistent file storage
For production workflows, the consumer ChatGPT file system is the wrong tool entirely. Use an Assistants API with properly managed file storage, where files persist until you delete them through API calls. That gives you explicit control over the full lifecycle: upload, retrieve, delete.
The API's file behavior is documented and predictable, which is what any serious integration needs. OpenAI's developer documentation describes how files are retained in the vector store and how cleanup should be handled programmatically. For regulated environments, Team or Enterprise workspace policies can align file retention with your organization's compliance requirements.
The takeaway: if you're building a product or an internal tool on top of file analysis, don't build it on consumer ChatGPT session uploads. You'll spend your weekends chasing expired-file bugs. Use the API layer where file persistence is an explicit, manageable feature.
ChatGPT Uploaded File Expiration Time Limit vs. Official Data Retention Policy
There's one distinction that keeps coming up in enterprise conversations, and it causes enormous confusion when people blur the lines. Product-level file expiration is not the same as OpenAI's formal data retention policy. They have different purposes, different timeframes, and different consequences.
What the Help Center says about content deletion and retention windows
OpenAI's Help Center and privacy documentation describe when content may be deleted from backend systems. The "up to 30 days" phrase appears in several consumer-facing summaries, and it generally refers to how long content may be retained for things like safety and abuse monitoring after a deletion request or after an account action [需核实]. It is not a promise that your uploaded files stay accessible in your chats for 30 days.
If anything, the relationship is inverted. Files often expire from the product first, while backend logs keep some trace of the conversation for a while longer. From a user's perspective, the file is gone long before the retention clock even starts on the backend.
This matters for privacy planning. If you upload a confidential contract to ChatGPT and later delete the conversation, you should assume some residual data may be retained for a limited period under OpenAI's policies. The exact time window depends on the product, the plan, and whether legal or safety exceptions apply. For the most current wording, check OpenAI's Help Center for the latest policy page rather than trusting a blog post from years ago.
How to align file workflows with your organization's data retention policy
If you're responsible for data governance at your company, you need a simple rule to communicate: do not treat casual ChatGPT chats as archival storage.
Establish a clear internal policy before someone uploads something sensitive by accident. A practical mapping table helps:
| File sensitivity | Recommended ChatGPT storage | Backup requirement |
|---|---|---|
| Low sensitivity, public info | Chat upload acceptable | Keep master copy in shared drive |
| Internal, confidential | Persistent Files/Projects if allowed | Daily local backup |
| Regulated, PII, legal | Do not upload to consumer ChatGPT | Use Enterprise controls or approved API storage |
| Each organization has different compliance obligations, so the table above is a starting point, not legal advice. Assign a responsible owner for the policy, document the retention schedule, and audit stale workspace files periodically. |
Frequently Asked Questions
Why do ChatGPT files expire?
ChatGPT stores uploaded files inside temporary sandbox containers rather than permanent cloud folders. These containers are subject to time-to-live limits, inactivity cleanup, and session resets. When the container is removed, ChatGPT loses access to the file, even though the chat preview may remain visible. Privacy requirements, data retention policy, and resource management all factor into this design.
How long before ChatGPT files expire?
There is no universal answer. Active context files may become unavailable after a few hours when idle, sandbox files expire when the execution environment resets, and persistent files in the Files area or API storage can last far longer. Free accounts generally expire faster than paid plans. For the practical ranges, review the retention table in the section above.
Does ChatGPT auto-delete files after 30 days?
The 30-day figure commonly comes from OpenAI's data retention policy, which describes backend content handling, not the visible file-expired message. Product-level expiration usually occurs much sooner than any 30-day window. The policy explains what happens to retained content after deletion, not how long your uploads remain accessible.
Can I recover an expired ChatGPT file?
No. Once ChatGPT loses access to the temporary sandbox copy, the file cannot be recovered through the interface. The only supported fix is to re-upload the original from your local device. For long-term projects, use persistent storage and maintain local backups to avoid relying on temporary chat uploads.
Conclusion
Files expire because ChatGPT's attachment storage is deliberately temporary: privacy, data retention policy, and server-load management all push toward automatic deletion. The retention windows vary by plan and by storage layer. Context files, sandbox files, and persistent library files behave differently, and confusing them leads to most of the frustration.
The good news is that the "file expired" error is usually fixable in one step: re-upload the file. The exceptions — immediate expiration after upload, systemic failures — point to platform incidents or reset issues, and they need a different diagnostic approach.
But the strongest strategy is prevention. Store long-term reference material in persistent areas. Don't switch models mid-task. Download outputs right away. Keep the local original safe.
Why do ChatGPT files expire? Because they were never meant to be permanent. The sooner you plan around that reality, the less it will disrupt your workflow.
Create your own file backup process now: save every original in a project folder, use persistent ChatGPT storage for anything you'll need again, and keep this article handy as your troubleshooting checklist. A two-minute habit today saves a re-upload headache tomorrow.
