Quick answer: It depends on the tier and, more importantly, on what's in the file. A contract is usually the worst case, because it's someone else's confidential information, not just yours — most commercial agreements contain a confidentiality clause that a third-party upload breaches regardless of what ChatGPT itself does with the data. File uploads also carry risks that pasted text doesn't: metadata, tracked changes, and hidden content people forget are even in the file.
The two are treated the same everywhere else on this topic, and they shouldn't be. Pasting a paragraph of text is one risk. Uploading the whole file behind it is a different, bigger one.
What's actually low-risk to upload
Not everything with a file extension is dangerous. A public report you're summarising for your own notes, a template you wrote yourself with no client details in it, a spreadsheet of your own numbers you're happy to see on a screen — none of that needs the caution below. The risk is proportional to two things: whose information it is, and whether the file carries anything beyond what's visible on the page. If both answers are "just mine, and what you see is what's there," upload away.
The NDA trap
Here's the part that gets missed. A confidentiality clause in a contract doesn't care what ChatGPT's data policy says. If you've signed an NDA or a contract with a standard confidentiality clause — which is most of them — you've agreed not to share that document with third parties. Uploading it to ChatGPT, even on a business tier where nothing trains on it, is sharing it with a third party. Your tier settings protect you from OpenAI using the content. They do nothing about the promise you made to the other party in the contract.
This applies even when your intentions are entirely reasonable — you're trying to get a quick summary, or check a clause means what you think it means. The breach isn't about intent. It's about the document leaving the two parties who were meant to see it. Before you upload anything with someone else's name on the confidentiality line, check whether you're actually allowed to.
What travels with a file that people forget about
A pasted paragraph is exactly what you typed. An uploaded file usually carries more than you meant to share:
- Document metadata — author name, company name, creation and edit dates, sometimes the file path from your own systems.
- Tracked changes — edits and deletions that look gone in the visible text but are still sitting in the file's history.
- Comment threads — internal notes, often more candid than the document itself, that a "final" version can still contain.
- Hidden sheets and formulas — in spreadsheets, tabs and rows that aren't visible on the active view but are still part of the file.
- EXIF data in images and scans — location, device, and timestamp information embedded in a photo of a document or a scanned page.
None of this shows up when you glance at the file before uploading. It's all still there — and a "final" version sent to a client is exactly the kind of file most likely to still be carrying an earlier draft's comments underneath it.
Scanned documents deserve a specific mention. A photo or scan of a paper contract can carry the same EXIF data as any other image — where and when it was taken, sometimes the device — on top of whatever text ends up in the chat once ChatGPT reads it. People treat a scan as "just an image of some words" and forget it's also a file with its own metadata trail.
File-type risk, roughly ranked
| File type | Main risk |
|---|---|
| Often a rendered contract or report; metadata and, if scanned, embedded image data | |
| Word (.docx) | Tracked changes and comments are the big one — a "clean" copy can still hold edit history |
| Excel/CSV | Hidden sheets, unused columns, and formulas that reference other files or ranges |
| Images/scans | EXIF metadata (location, device, timestamp) and anything visible in the margins of a scan |
| Code | Comments, hardcoded credentials, internal hostnames — easy to miss in a quick copy-paste |
Safe-handling steps
- Redact before you upload. Replace names, figures and identifying details with placeholders wherever the substance of your question doesn't need them.
- Strip metadata first. Most office software has a built-in document-inspector tool — use it before export, not after.
- Extract the clause, not the contract. If you want help understanding one paragraph, paste that paragraph. You don't need to upload the whole agreement to ask about one part of it.
- Use a temporary chat for anything sensitive. It doesn't save to your history and isn't used for training, which limits the blast radius of a one-off mistake.
- Check the confidentiality clause before uploading anyone else's document. If in doubt, don't — ask the other party, or keep the analysis inside a tool that never sends the file to a third party at all.
When uploading stops being the answer
If you're uploading the same set of documents every week — the same contract templates, the same policy pack, the same set of reports — manual upload stops being a workflow and starts being a chore, and redacting the same fields every time is a sign you've outgrown copy-and-paste. The more sustainable option at that point is retrieval-augmented generation (RAG): a system that keeps your documents inside your own infrastructure and answers questions against them directly, rather than sending a fresh upload to a public chatbot every time someone needs an answer.
That's a genuinely different kind of build to a ChatGPT subscription, and it's worth understanding the trade-offs before you commit to one — our guide to RAG, fine-tuning and prompting covers what each approach actually does and roughly what it costs. If you're handling contracts or company documents at real volume, AI Engineering is where that kind of system gets scoped and built properly, with your data staying under your own control throughout.
For everyone else — the occasional contract question, the one-off report summary — the steps above cover it. Redact, extract, use a temporary chat, and think twice before anyone else's confidential document goes anywhere near a public tool.