Read Word documents with full formatting — rendered in your browser, never uploaded
word/document.xml plus its styles, and paints the pages — headings, tables, lists, images — exactly as the file describes them. You also get document stats (words, paragraphs, page blocks) and clean printing. Free, no account, and the document itself never leaves your machine; the only downloads are ~170 KB of rendering code from a CDN.| Part | Carries |
|---|---|
[Content_Types].xml | The manifest — which parts exist and their types |
_rels/.rels | Relationships tying the package to its main document |
word/document.xml | The body: every paragraph, run, table, and page break |
word/styles.xml | Named styles — headings, lists, spacing — the body refers to |
word/numbering.xml | List definitions for bullets and numbered items |
word/media/* | Images and other embedded media (when present) |
docProps/core.xml | Title, author, dates — document metadata |
That's the whole trick: "Word format" since 2007 is Office Open XML — zipped XML — which is why a browser can read it without a license, and why renaming .docx to .zip and peeking inside is a time-honored party trick.
| Route | Installs anything? | Your file |
|---|---|---|
| This browser viewer | No — a tab | Stays local the entire time |
| Word for the web | No, needs a Microsoft account | Uploaded to Microsoft's cloud |
| Google Docs | No, needs a Google account | Uploaded to Google (import step) |
| LibreOffice / other word processors | Yes, a full application | Stays local, fullest fidelity |
| OS quick-look (Preview, File Explorer preview) | No | Stays local, read-only, feature-thin |
The browser route wins on convenience-for-confidentiality: contracts, résumés, medical letters, and legal drafts have no business on someone else's server just so you can read them.
| Component | Size | Role |
|---|---|---|
| JSZip 3.10.1 (MIT) | ~95 KB | Unzips the .docx package in memory |
| docx-preview 0.4.0 (Apache-2.0) | ~73 KB | Turns the XML into styled HTML pages |
| Your document | — | Never uploaded — read from disk into the tab |
A .docx isn't a blob — it's a package. The paragraphs you're reading in the viewer right now exist as <w:p> elements inside word/document.xml; their look comes from styles.xml; images are files in word/media referenced by relationships. The viewer's job is translation: unzip the package, walk the body XML, and emit equivalent HTML — headings to headings, table grids to real HTML tables, page breaks to new page blocks — while the style part supplies the formatting. Because it's translation and not screenshotting, text stays selectable and searchable, and printing comes out clean.
The word counter doesn't guess from the rendering: it reads the same XML the renderer does, pulls every text node the spec says holds content (<w:t> elements), decodes entities, and tokenizes. "Page blocks" counts the rendered page-sized sections — a good proxy for pages, though without a full layout engine, exact pagination is an approximation by nature. Characters, paragraphs, and file size are exact.
Open a .docx, or load the sample first if you just want to see the thing work. Scroll the rendered pages, read the stats strip, and use Print when you need paper — the print stylesheet strips everything but the document. For everything past reading: convert it to PDF, merge it with others, or pull pages out with extraction once it's a PDF.
Press Load the sample and watch the numbers: the file is 3,219 bytes, containing 6 parts in its ZIP — the manifest, two relationship files, the body, styles, and list numbering. The body XML carries 23 <w:p> paragraph blocks; 12 of them are the cells of the three-row budget table. The tokenizer counts 329 words across the whole thing. It has one explicit page break, so it renders as two page blocks: the intro and bullet list, then the heading, table, and closing. Every number in this paragraph is computed live by the same code paths the page uses on your file — that's the point of shipping a sample whose stats you can check.
Open it in a browser-based viewer: the .docx format is a ZIP of XML parts, and a JavaScript renderer can read those parts and paint the pages locally. You get headings, styles, tables, lists, and images without owning Word. Word Online and Google Docs also open .docx, but they do it by uploading the file to a server — a real difference for confidential documents.
No. This viewer unzips the .docx in your browser's memory, reads the XML, and renders it on the page. The only network requests are for the rendering code itself from a CDN — under 170 KB total. The document's contents never leave your machine.
Very close for standard documents — headings, bold and italic, alignment, lists, tables with borders, and inline images all render from the file's own styles. Two limits: fonts are not embedded in most .docx files, so your browser substitutes its closest match, and deeply exotic features (macros, embedded OLE objects) don't render because they don't belong to the page layout at all.
No — .doc is the pre-2007 binary Word format, a completely different file layout from .docx. This viewer reads the Office Open XML .docx format only. For a .doc, convert it first (Word, LibreOffice, or most modern word processors save-as .docx), then view it here.
This is a reader: it renders faithfully and prints cleanly, but editing is out of scope by design — editing logic is how viewers end up mangling files. To transform the content instead, our Word to PDF converter produces a PDF from the same .docx locally, and our other document tools handle merging and page surgery on the result.
The rendered text is the document's current state; revision marks and margin comments are not drawn. That is usually what you want when reading — but if you need to inspect a document's tracked changes, open it in a word processor that supports reviewing.