You cannot see attachments in Outlook when the message body and the attachment metadata arrive through different channels — the body syncs through Exchange ActiveSync or MAPI/HTTP while the attachment is fetched separately from the Exchange server's content store, and a failure at any step in that chain leaves a paperclip with no file behind it. The most common culprits are a corrupted local cache, a Mailbox quota that has silently blocked attachment delivery, and attachment-blocking policies that suppress or strip unsafe file types. In most cases the attachment exists on the server and is visible in Outlook on the web, which proves the problem is client-side rendering, not message loss.

That distinction matters more than most thin explainers admit. Outlook is not a single program that shows you a message; it is a thin client attached to two very different data paths. Understanding which path the attachment travels explains why the same message can show a file on your phone, show a paperclip on your desktop, and show nothing in a shared mailbox — and why clearing the cache sometimes fixes it and sometimes deletes the only copy you could see.

The two-path rendering mechanism

Every message with an attachment is stored on the server as a MIME entity with discrete parts: headers, body text, body HTML, and one or more attachment parts, each with its own content type and content-transfer-encoding. The server splits this into a message table row (the body, usually stored as the HTML part) and a separate attachment table. Outlook synchronizes the message table first and the attachment table second, sometimes seconds apart, sometimes hours apart on a throttled connection.

When Outlook renders a message, it reads the message-body cache and checks a local attachment registry for the matching item IDs. If the registry entry is missing, unread, or marked with a failed download state, Outlook draws a placeholder but cannot resolve the file. The paperclip in the message list comes from the message metadata — the flag that an attachment part exists — while the attachment pane in the reading view comes from the resolved binary. That split is why you can see a clip icon yet preview nothing.

The second path is simpler but easier to break: attachments larger than roughly 10 MB on a standard connection, or larger than the configured attachment limit, may be delivered as a reference — a link to the Exchange content store rather than the full binary. Outlook then fetches the binary on demand. If the fetch is throttled, blocked by a firewall, or times out, the message displays with a generic attachment name or no name at all. Plain language: the body arrived, the envelope with the file arrived, but the file did not.

A corrupted or oversized OST cache file is the third failure point. The offline store holds both the body and attachment binaries for cached mode. When the store reaches its file-size ceiling or becomes inconsistent after an unclean shutdown, Outlook stops writing new attachment binaries but keeps syncing body text. The visible symptom is a mailbox that appears current for text and stale for files, which sends most people looking at the wrong cause.

Quantified context: limits, timings, and thresholds

Exchange Server's attachment size defaults and client value ranges vary by version and by what your administrator set, so no single number is universal. What is stable across versions is the tiered behavior: small binaries in the tens of megabytes are typically streamed into the cache; larger ones may be reference-delivered; anything above the server's configured maximum is rejected at send time with a nondelivery report, not silently dropped. If you sent a file over, say, 25 MB and received no bounce, the message was accepted, which means the attachment exists on the server and your client is the problem.

Outlook's own size caps apply too. Traditional Outlook for Windows warns at 20 MB and blocks above your organization's cap, often 35 MB or 50 MB in hosted deployments. Outlook on the web enforces the server-side limit. Outlook for Mac historically handled very large files differently, which is why attachments that fail in one client often appear in another.

Cached mode compresses and deduplicates content, then writes it into the OST, which is capped at 50 GB in modern builds before the client warns or refuses. A mailbox carrying years of attachments can approach that ceiling quietly. Once Outlook stops expanding the store, attachment downloads queue forever behind body sync, and the user sees a message list that updates while every new file fails to appear.

Sync interval and connection type also matter. On a full MAPI/HTTP connection, attachment metadata typically syncs with the message; on cached mode, it may lag by one sync cycle, which defaults to a couple of minutes on a healthy connection but stretches as the client backs off after errors. Paperclip-without-file is therefore normal for a short window after arrival — and abnormal if it persists past a sync cycle.

Edge cases that mimic a missing attachment

Winmail.dat is the classic edge case: a TNEF-encoded attachment that non-Microsoft mail clients render as a single opaque file named winmail.dat. The file is not missing; it is packed. Outlook on Windows decodes TNEF natively, but Outlook for Mac, most webmail, and mobile clients may not, so the recipient sees one mystery file instead of three inline images and a PDF.

Rich-text versus HTML message format produces a related illusion. Messages composed in Outlook's proprietary rich-text format carry attachments inside the body stream, so a client that expects MIME parts shows a blank attachment area even though the file is present. Switching the message to HTML or plain text on the sender's side resolves it for every recipient without resending the file.

Blocked file-type policies are the most consequential edge case because the file never reaches your cache. Microsoft 365 and Exchange apply malware filters and transport rules that can quarantine a message and notify only the sender, or strip an attachment and deliver the remainder. Extensions like .exe, .js, .bat, and certain macro-enabled Office formats are the usual targets. If the sender received no bounce and you received a message with no attachment, check whether a transport rule acted — your administrator can confirm from message trace.

Shared mailboxes and delegation add a permissions layer. Attachment access can fail while body access succeeds when the delegate has read permission on the mailbox but not on the attachment-bearing folder's item-level security. In hybrid environments, an attachment stored in an on-premises mailbox and read through a cloud client can render as a link that neither side can resolve.

A counterintuitive detail worth keeping: the paperclip is metadata from the message row and is one of the last things rebuilt after cache repair. A message can show a clip icon for days after the file itself has been evicted from local cache, which is why "the icon is there but the file is not" is often a cache-eviction symptom rather than a server-side loss.

Common misconceptions

The most common wrong assumption is that the file was deleted. Server-side deletion produces a different signature: the message body remains but the attachment pane disappears entirely with no placeholder, and the sender's message trace shows the attachment was present at delivery until a policy or retention change removed it. A placeholder or grayed attachment entry indicates the client lost track of the binary, not that it was purged.

A second misconception is that re-sending the file fixes a policy block. It does not. Transport rules and malware filters act on every delivery attempt, so the same extension will be stripped again. The fix is a rule change or a safe-link request, not a resend from a different email address.

A third is that clearing the Outlook cache is harmless. Deleting the OST forces a full re-sync, which can take hours on a large mailbox and can consume bandwidth you do not have. More importantly, if cached mode had been the only place a message body existed after retention moved it, clearing the cache loses that local copy. Repair the store before deleting it.

Finally, inline images and attachments are not the same object. A pasted screenshot often travels as an inline cid: reference that some clients treat as body content rather than an attachment. If the recipient's client suppresses remote content, the image is blank but the message carries no attachment pane at all — a rendering choice, not a lost file.

Symptom Most likely cause Where the file actually is
Paperclip visible, attachment pane empty Cache attachment registry missing Server; fetch failed
Attachment name shown as winmail.dat TNEF rich-text encoding Inside the packed file
Message body present, no attachment at all Transport rule stripped it Quarantined or removed server-side
Attachment shows in webmail, not desktop Local cache or OST corruption Server; client cannot render
Attachment visible only when forwarded Inline cid reference, not a file Embedded in body HTML
File received but zero bytes Quota or throttling at download Server; fetch truncated
No message at all, sender got bounce Size exceeded server cap Never delivered

A time course of a failing attachment

Attachment visibility follows a predictable sequence, and knowing the stage narrows the diagnosis quickly.

Elapsed time after send What should happen What a failure looks like
0–30 seconds Message row and body sync to client; paperclip appears No message arrives; transport rule held it
30 seconds–2 minutes Attachment metadata syncs; file name resolves Paperclip with blank name persists
2–10 minutes Binary fetches and caches locally Preview spins and times out
10 minutes–1 hour Full offline copy available Attachment works online only, fails offline
Hours Cache compacts and evicts older binaries Old attachments vanish from cache, server copy intact
Days Retention or policy may alter the item Attachment removed by policy with body retained
Weeks Store size ceiling approached New attachments stop caching entirely

The key insight from the timeline is that "missing" attachments cluster at two windows: immediately after delivery (metadata or policy failure) and long after delivery (cache eviction or retention). A file that was visible yesterday and gone today with no message changes points at the cache, not at the sender.

Practical actions and thresholds

Work from least destructive to most destructive, and verify with Outlook on the web at each step. If the file is visible in webmail, the client is the fault; if it is not, the server or transport path is.

Open the same message in Outlook on the web first. This single check splits client-side from server-side causes and costs a minute. Toggle the cached-mode setting under Account Settings, restart Outlook, and allow one full sync cycle before judging the result. Run the built-in repair tools in order: the Microsoft Support and Recovery Assistant first, then scanpst.exe (the OST repair utility) from the Office installation folder, then an Outlook profile rebuild only if repair fails. Check mailbox size against the store limit and archive years of mail before the OST approaches its ceiling. Archiving and moving archived mail to a separate store keeps the primary cache efficient. Ask the administrator to run a message trace if the attachment is absent in webmail. Trace confirms delivery, transport-rule action, and quarantine rather than guessing from symptoms. For a sender, switch rich-text messages to HTML before sending anything with multiple attachments, which eliminates the winmail.dat class of failure for mixed-client recipients.

Threshold guidance, stated once to reconcile the competing numbers: treat 20 MB as the practical warning line where Outlook will start to behave differently, treat your organization's configured cap as the hard ceiling, and treat 50 GB as the OST ceiling that triggers cache slowdowns long before it is reached. Keep the mailbox below roughly half the store limit to leave room for attachment binaries, which are the largest items in the cache. For attachments you must preserve long term, save them out of the message and into a file store the client does not manage, then rely on the server copy as the backup.

Limitations and what this explanation cannot settle

Every mechanism above depends on server configuration, client version, and tenant policy that this article cannot see. Exchange throttling policies, malware filter settings, retention rules, and OST format limits vary by organization and by release, so a fix that applies to one mailbox may be inert or harmful on another. Version-specific attachment caps in particular change with each Outlook release, and quoting one as universal is how thin explainers go wrong.

Nor can a science explainer diagnose a specific mailbox. The symptoms described here overlap with genuine message loss, deliberate deletion, conditional-access blocks, and litigation-hold behavior that only an administrator can trace. Where the file still exists on the server, the remedy is usually a client-side sync or cache issue; where it does not, the remedy belongs to the mail flow, and no amount of local repair will recover it.

If your situation involves regulated data, legal hold, or a compliance investigation, treat the transport-rule and retention explanations as leads, not conclusions. Your organization's IT or compliance administrator, or a qualified local professional in your jurisdiction, can confirm what happened to a specific message and whether recovery is permitted.