What an Xactimate template or estimate file actually is
A real Xactimate file is not a picture of an estimate. It is structured data: sections, line items, quantities, unit prices, and totals, laid out so the software can read them. The extension tells the software which document it is holding. An .esx file is an estimate, and a .skx file is a sketch, usually a floor plan. Both are files you hand to the software, not pages you type over.
Around the industry, the word template is used for two things. One is a reusable start file: a worked estimate you open and adapt for the next job. The other is the file format itself, the shape a document must have before the software will call it an estimate. Both point at the same object, which is why the file shape is the part that matters.
If you have never looked inside one, a public sample is worth more than a paragraph of explanation. That is why we publish one. trueplanSample.SKX is a real Matterport TruePlan sketch export, sitting in our resources/skx-samples folder, and it is the file this post uses to show what the container looks like.
The estimate file follows the same idea. Inside a real .esx sit the sections, line items, quantities, unit prices, and totals for the job, and the software opens them as a working estimate rather than a scan of a page. The .skx sketch is the geometry side of the same job: the floor plan exported from the scope PDF. Between the two, a file set can carry the full picture of what a conversion produced.
The container: a ZIP that holds an encrypted inner document
Open the sample and you find a ZIP archive. Inside it sits a single member named XACTDOC.ZIPXML, and that member is the real document. It is encrypted: the inner XML starts with the byte header 04 04 0A and is AES-256 encrypted. To a text editor the file looks like scrambled text, and that is by design.
Why would a document be encrypted on purpose? Estimates carry price data tied to licensed price lists, and carrier scopes carry pricing meant to be read by the software rather than edited in a text editor. The same logic applies to sketches. There is a matching key, and an installation holding that key opens the file cleanly.
The sample is 58 KB on disk, and its extracted XML is about 1.1 MB. That difference is the whole point of the container: the outer ZIP keeps the file small, and the encrypted inner XML keeps the content inside the software. The same decryption step our pipeline uses for ESX files opens the SKX, because sketches and estimates share the container structure.
So if a file will not open in a text editor, that is not a sign it is broken. It is the normal layout. What matters is that the software reads it, and that the content inside matches the estimate you wrote.
Why templates and sample files matter
A known-good file to open is the fastest way to learn the shape. You can see how sections are named, how a line item holds a code, quantity, and unit price, and how a sketch ties walls, rooms, and openings together. When your own output looks different, the sample shows you exactly where to look.
There is a second reason. A file can carry more than the estimate. Files from older tools often carry a price-list name, a tax block, minimums, and fee sections, all inherited from wherever the file was created. Since 2026-09-02 our exported .esx carries none of that: no price-list name, no tax block, no minimums. The receiver applies its own list on import.
That is the intended design, and it shows up as a single question in Xactimate: import the file, and the software asks whether to reprice. The exported file asks Xactimate to reprice, and that is the desired result: your chosen price list does the pricing. A real import test in Xactimate confirmed the file opens clean.
How much of a real file actually gets priced by the receiving list? Measured across 289 real claim files and 7,525 line items, 2,756 line items, which is 36.6%, carry a code our catalog recognizes. The median estimate file moves 17% of its lines, and 39 files move none at all. The rest keep their PDF price, which is exactly what a template should respect.
The sample is a sketch rather than an estimate, and that is deliberate: sketches are the format people see least and question most, while the container rules are identical, so what you learn on the sketch applies to the estimate.
What you can do with a real sample file
Open it in the software and compare it with an estimate you are working on. Look at how the sections are grouped, how line items carry codes, quantities, and unit prices, and how a sketch references rooms and walls. The differences tell you what a clean document looks like.
Keep it as a reference while you check your own output. We publish a free ESX validator and an ESX reprice checker, both built for this kind of sanity check, and a free code search that covers the codes used in claims.
If you work from a carrier scope PDF, convert it and compare the result against the sample. Same document type, same container, and the prices still come from your PDF, never from a guess.
A converted estimate is worth the same treatment. Open the .esx the converter produced, scroll the sections, and look for flagged lines: a flagged line keeps its PDF price because the catalog did not recognize the product code, so the total never silently changes. Knowing exactly which lines kept their original price is the whole point of the check.
How ESXPress builds these files from a carrier scope PDF
ESXPress takes an insurance carrier estimate PDF, called a scope, and converts it into a Xactimate .esx file: the same line items, the same quantities, and the unit prices from the PDF. The PDF price is the source of truth. Every line carries the price from the customer's own PDF, and if a product code is not recognized, the PDF price is kept and the line is flagged. The total never silently changes.
If the scope has floor plans, they come out too: a Xactimate-ready .skx sketch file per floor page, or a zip of them. The first export builds the rooms and takes a few minutes; later exports are fast. All sketch exports use the same pipeline as production files, and an automated upload-to-download smoke test runs every 30 minutes.
Both file types wait at the end of the same flow: upload the scope PDF, get back a real .esx estimate and, where it applies, the matching .skx sketch. That is the flow worth testing against a real sample.
Getting from a sample to your first real ESX file
Start with the sample in hand, then convert one of your own scopes and compare them side by side. Where the conversion differs from a real template, the difference is usually a flagged line: a code our catalog does not recognize, still carrying its PDF price.
Descriptions only get you so far. Open a real file, run it through the validator, and keep the container rule in mind: outer ZIP, encrypted inner XML, and the software reads it. That is what a Xactimate template or estimate file actually looks like.
The sample ships alongside its extracted XML, so you can compare the locked document with the plain version and see exactly what the container holds. That is the whole point of publishing it: a real file, opened, and explained.