IDML File Documentation

---

Technical details

Feature	Value
Full name	Adobe InDesign Markup Language
File extension	.idml
MIME type	application/vnd.adobe.indesign-idml-package
Format type	ZIP package of XML parts (binary container, XML payload)
Developer	Adobe Inc.
Introduced	2008 (InDesign CS4), replacing INX
Open standard	Partial — documented XML in a ZIP, Adobe-controlled schema
Container / base format	ZIP (same convention as EPUB and ODF)
Magic number	50 4B 03 04 (ZIP local file header, “PK”)
First entry	mimetype, stored uncompressed
Master index	designmap.xml
Key folders	Stories/, Spreads/, MasterSpreads/, Resources/, XML/, META-INF/
Native sibling	.indd (binary working file)
Predecessor	.inx (InDesign Interchange, CS3 and earlier)
Text encoding	UTF-8 / UTF-16 XML
Related extensions	.indd, .indt, .idms, .inx, .pdf
Specification	adobe.com/devnet/indesign/documentation.html

What is an IDML file?

IDML stands for InDesign Markup Language, Adobe’s open, XML-based interchange format for InDesign layouts. Adobe introduced it with InDesign CS4 in 2008, retiring the older binary-ish INX interchange format. Where the native INDD file is a closed binary that only a matching or newer InDesign can open, an IDML is deliberately portable: it expresses the same page layout — frames, text, styles, colours, master pages — as a set of readable XML documents.

That portability is the whole reason IDML exists. A newer InDesign can always open an older INDD, but an older InDesign cannot open a file saved by a newer version. Exporting to IDML is the bridge: the newer InDesign writes an IDML, and the older one imports it. The same file is also the doorway into non-Adobe applications — Affinity Publisher, QuarkXPress and the free Scribus all import IDML — and into automated publishing and translation pipelines, where software reads and rewrites the layout’s XML directly.

The trade-off is fidelity. IDML is an interchange format, not the preferred working format. A round-trip through IDML can drop or slightly alter InDesign-specific features, so designers keep INDD as their master and use IDML for transport. And IDML is editable layout data, not a finished page image: to simply view or print a design, the right deliverable is a PDF exported from the layout.

The ZIP package and the mimetype marker

An IDML file is not a single document; it is a ZIP archive, byte-for-byte the same container used by EPUB, ODF and countless other formats. It begins with the ZIP local file header 50 4B 03 04 (“PK”), and renaming a copy to .zip lets any archive tool walk its contents. Inside is a tree of XML parts plus a few folders, each responsible for one aspect of the layout.

The first entry in the archive is a small file literally named mimetype, stored uncompressed, whose only content is the string application/vnd.adobe.indesign-idml-package. Storing this part first and uncompressed is the OCF convention IDML shares with EPUB: it lets a reader identify the package type by reading the opening bytes of the ZIP, without decompressing anything. The top level then looks like this:

myfile.idml (a ZIP archive)
 ├─ mimetype              first, uncompressed: the package type string
 ├─ designmap.xml         master index tying every part together
 ├─ Stories/              text content, one Story_*.xml per story
 ├─ Spreads/              page geometry: spreads, frames, positions
 ├─ MasterSpreads/        master pages
 ├─ Resources/            Fonts.xml, Styles.xml, Graphic.xml, Preferences.xml
 ├─ XML/                  tags and structured/tagged XML content
 └─ META-INF/             container.xml package metadata

Because the payload is plain XML, an IDML is transparent in a way INDD never is: a developer can open Styles.xml to read every paragraph style, or edit Story files to change text, without owning InDesign at all. That transparency is exactly what makes IDML the format of choice for programmatic publishing and for CAT (computer-assisted translation) tools that process the Story XML.

designmap.xml: the master index

The part that makes the package cohere is designmap.xml. It is the document’s table of contents: it declares the document-level settings and references every other part — each spread, each story, each resource file — so a reader knows which XML files belong to the document and in what relationship. Opening an IDML in InDesign means parsing designmap.xml first, then following its references out to the spreads and stories.

The separation of content from geometry is deliberate and mirrors how InDesign itself thinks. Text lives in Stories/, one Story_*.xml per threaded story, holding the words and their inline formatting overrides. The physical arrangement — where the text frames sit on the page, their size and stacking — lives separately in Spreads/. A single story can be threaded across several frames on several spreads, so keeping the text in one place and its containers in another is what lets the layout reflow without rewriting the words.

Stories, spreads and resources

A Story in IDML is a tree of XML elements. At the top is the story, then paragraph-style ranges, then character-style ranges, and finally the runs of actual text content. Formatting is applied as attributes and as references to named styles, so a run of text that uses the “Body” paragraph style carries a reference to that style’s definition rather than repeating its properties. This is why editing the definition in Styles.xml changes every paragraph that uses it.

A Spread holds the page geometry. Each spread lists its pages and the page items on them: text frames, rectangles, graphic frames, lines. A text frame does not contain its own text; it carries a reference to the story that flows through it, closing the loop between Spreads/ and Stories/. Positions and sizes are recorded as coordinates and transform matrices, so the same numeric layout model reconstructs the page precisely.

The Resources/ folder holds everything shared across the document. Styles.xml defines paragraph, character, object and table styles and the colour swatches; Fonts.xml records which fonts the layout references (it references them, it does not embed them, which is why a missing font substitutes on open); Graphic.xml records stroke and fill definitions; and Preferences.xml carries document-wide settings. Because these are separate parts, a translation or automation tool can rewrite the Story text while leaving styling and geometry untouched.

IDML against INDD, and against INX

The relationship between the three interchange generations is easy to state. INX (InDesign Interchange) was the CS3-and-earlier XML export; it is obsolete and current InDesign no longer writes it, so the only meaningful direction is INX→IDML. IDML is the current XML interchange package described here. INDD is the native binary working file: compact, fast to open in its own version, and the format designers actually edit in.

The reason IDML round-trips are “lossy” while INDD saves are not is that INDD is InDesign’s exact internal state serialised to disk, whereas IDML is a documented model that a newer feature may not fully express. When a layout uses something the IDML schema does not cover cleanly, the export approximates it. For everyday layouts the difference is invisible; for complex documents it is why a designer round-tripping through Affinity Publisher or Scribus should expect minor cleanup. The correct mental model is that INDD is the source of truth and IDML is a faithful-but-not-perfect transport wrapper.

Opening and inspecting an IDML

Adobe InDesign opens an IDML with File › Open and converts it to an untitled document you then save as INDD. Without InDesign, Affinity Publisher is the strongest importer (free since 2025), Scribus opens most IDML files for free with some styling loss, and QuarkXPress imports them on a trial. For anyone who just wants to read what is inside, the ZIP nature of the format is the shortcut: copy the file, rename the copy to .zip, and open the XML parts in any text editor. That is often the fastest way to extract the text or confirm which fonts and styles a layout expects.

Because an IDML is XML in a ZIP with no executable content, opening one is not a security risk in the way a macro document or executable is. The realistic hazard is fidelity, not malware: a non-Adobe importer may not reproduce every InDesign feature exactly, so verify complex layouts after import rather than assuming a pixel-perfect result.

Frequently asked questions

Is an IDML file really a ZIP?

Yes. Internally an IDML is a ZIP package (magic bytes 50 4B 03 04) of XML files, with a leading uncompressed mimetype marker, exactly like EPUB. Rename a copy to .zip and any archive tool will list designmap.xml, the Stories/ and Spreads/ folders, and the Resources/ XML.

Why would someone send an IDML instead of an INDD?

Because IDML crosses versions and applications. An older InDesign cannot open an INDD saved by a newer one, but it can import that layout as IDML. IDML is also how a layout moves into Affinity Publisher, Scribus or QuarkXPress. Open it and save as INDD in your own InDesign.

Why do fonts go missing when I open an IDML?

IDML references fonts by name in Fonts.xml; it does not embed the font files themselves. If a referenced font is not installed on the machine opening the file, the application substitutes another, which can shift the layout. Install the referenced fonts, or ask for a PDF if you only need to view the design.

References

• Adobe Developer — InDesign documentation (IDML)
• Adobe — InDesign product page
• Scribus — open-source desktop publishing (IDML import)

Feedback

Was this page helpful?

Yes No

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.