Batch Creating Sheets in Revit: From Excel to Sheet Set

A hundred-sheet drawing set does not start as a hundred sheets. It starts as a spreadsheet — a sheet index someone typed in Excel, with a number, a name, and maybe a discipline or an issue date for every drawing the project will ever produce. Then someone has to turn that spreadsheet into actual Revit sheets: open the New Sheet dialog, pick the title block, click OK, rename the number, rename the name, and repeat — ninety-nine more times. It is the most mechanical hour in all of documentation, and every firm pays it on every project.

This article is about collapsing that hour. It covers how to create and number sheets in vanilla Revit — including the native trick most people miss — how to do it in Dynamo and when that is genuinely the right call, and, once you've outgrown both, how a purpose-built tool takes you from an Excel sheet index straight to a finished, print-ready sheet set. Everything here works today; the manual method costs nothing but time.

What "batch creating sheets" actually means

A Revit sheet is more than a number and a name. Each one carries a title block (the family that draws the border and the title bar), a set of parameters (discipline, drawn-by, revision, issue date — whatever your template defines), and, eventually, the viewports and schedules placed on it. "Batch creating sheets" is the job of producing many of these at once, consistently, from a list you already have.

Break it into the four things you are really trying to do:

1. Create the sheet — a real sheet, with a title block, not a placeholder.
2. Number and name it — usually by a pattern (A-101, A-102…) or straight from a list.
3. Fill its parameters — the metadata your title block and schedules read.
4. Organize it — drop it into a print/publish set so it's ready to issue.

Vanilla Revit can do all four. It just makes you do them one sheet, one dialog, one field at a time. Here's the complete manual workflow, because you should know it — the day a plugin isn't installed, you still have to deliver.

How to create sheets manually (vanilla Revit)

The one-at-a-time way

View → Sheet (or right-click Sheets in the Project Browser → New Sheet). Revit asks for a title block; pick one and click OK. A new sheet appears with the next available number. Select it in the Project Browser and, in Properties, edit Sheet Number and Sheet Name. Repeat for every sheet.

For five sheets this is fine. For a full set it is the mechanical hour — and it's error-prone: a mistyped number, a skipped one in the sequence, a name that doesn't match the index.

The native batch trick: placeholder sheets in a Sheet List

Most people never learn this one. Revit has a spreadsheet-like grid built in — the Sheet List schedule — and it can create sheets in bulk.

View → Schedules → Sheet List. Add the fields you want to edit (Sheet Number, Sheet Name, and any sheet parameters). With the schedule open, the ribbon's Rows panel lets you insert new data rows (the control is labelled New or Insert Data Row depending on your Revit version). Each new row Revit adds is a placeholder sheet — a row you fill in like a spreadsheet: type the number, type the name, tab to the next, add another. In minutes you have fifty placeholder sheets, all numbered and named, edited in a grid instead of through fifty dialogs.

The catch — and it's a real one — placeholder sheets are not real sheets. They hold a number and a name for planning, but they have no title block and you cannot place a view on them. To turn a placeholder into a real sheet, open View → Sheet again: the New Sheet dialog lists your placeholder sheets, and selecting one converts it into a real sheet with the title block you pick. You do that conversion one placeholder at a time.

So the native trick gets you fast bulk numbering and naming, then hands the tedium back for the title-block conversion. Still, for planning a set it's the best stock Revit offers — learn it.

Numbering by a pattern

Revit's New Sheet dialog auto-increments the number, but only in its own way. If your standard is A-101, A-102 or A-201-per-discipline, you'll be retyping. The Sheet List schedule at least lets you type numbers down a column quickly. There is no native "generate A-{start} with three-digit padding across 40 sheets" — you type them, or you paste them from Excel cell by cell (Revit schedules don't reliably accept a bulk paste into new rows).

Assigning a print/publish set

Once your sheets exist: File → Print → Select… → New to create a named set and tick the sheets that belong to it (or, in recent Revit, the Sheet Set feature). This is the "…to sheet set" half of the job. It's manual ticking, but it's quick, and it's how the set becomes something you can issue in one action.

That's the whole vanilla workflow. It works. It just doesn't scale.

The Dynamo way (and when it's the right call)

Dynamo is the honest middle ground, and plenty of teams stop here — rightly, sometimes. A basic "sheets from Excel" graph is well-trodden:

• Data.ImportExcel (or a CSV node) reads your sheet index into a list of numbers and names.
• A title-block-type node feeds the family symbol to use.
• Sheet.ByNameNumberTitleBlockAndView (out of the box, or the richer variants in packages like Genius Loci, Rhythm, or archi-lab) creates one sheet per row.
• More nodes, if you want them, write parameters and place a view.

When Dynamo is genuinely the right tool:

• You already run Dynamo and have the graph. If a working "Excel → sheets" graph is already in your library, running it costs nothing.
• It's a one-off. A single project, a single import, done once — reaching for a graph is fine.
• You need bespoke logic. Some rule specific to your office — derive the sheet name from three parameters, split sets by a naming convention, create sheets only where a matching view exists — is exactly what Dynamo's flexibility is for. A packaged tool exposes the options its author chose; a graph does whatever you wire.
• You want to learn, or you enjoy it. Dynamo is a real skill, and building the graph teaches you the API.

Where Dynamo starts to cost more than it saves:

• Version fragility. A graph built in one Revit version routinely breaks in the next — a renamed node, a package that hasn't updated, an out-of-the-box node that moved. The graph you trust in 2024 may throw red in 2026.
• Package dependencies. The good sheet nodes live in third-party packages. Everyone who runs the graph needs the same packages at the same versions, or it fails on their machine.
• No preview, no validation. A graph writes when you hit Run. There's no "here's what will happen, and here are the three numbers that already exist" step before it touches the model. You find the duplicate after it's created.
• Error handling is yours. One bad row — a blank number, a name with an illegal character — and a naïve graph either stops or half-finishes. Robust handling is more nodes you build and maintain.
• Sharing and maintenance. The graph is a file someone owns, understands, and keeps working. When they leave, it's an orphan — multiplied by every custom graph a firm accumulates.

None of that makes Dynamo wrong. It makes it a build-and-maintain choice. If you want the result without owning the graph, that's where a purpose-built tool comes in.

Where the manual (and DIY) methods break

The vanilla workflow and a hand-built graph both solve the problem once. They break under the same three pressures:

• Repetition. Every project starts a new set. The mechanical hour, or the graph babysitting, comes back every time.
• Consistency. Manual numbering drifts; a graph without validation writes duplicates and typos straight into the model.
• The whole job, not half. Native gets you numbering but hands back title blocks and view placement; a basic graph creates sheets but not the print set, not the template placement, not the multi-model stamp. Stitching the halves together is the real work.

At that point you want one dialog that reads the list, shows you what it will do, and does all four steps — create, number, fill, organize — at once.

From Excel to sheet set: Create Sheets (free)

Create Sheets is B45 Labs' sheet-batch tool, built around exactly the workflow this article is about: author a sheet index in Excel, import it, preview it, and create a finished, print-ready set in one pass. Here's what it actually does — every capability below is in the shipped tool.

1. Start from the Excel template. Click Download template and Create Sheets writes a styled .xlsx: a Print Set field and a Title Block field at the top, SheetNumber and SheetName columns, and a few example parameter columns marked [Shared Parameter] — each with a hover comment telling you to rename it to one of your real shared or project parameters. You fill it in Excel, the tool everyone already knows, one row per sheet.
2. Import it back. Import reads the workbook into the preview grid: every row becomes a sheet, and the Print Set and Title Block fields you filled at the top pre-select in the window. Any header you renamed to a parameter name becomes a parameter column — you type the plain name ("Sheet Discipline"), not a code. Dates are read the way Excel displays them, so an issue-date column arrives as the date you typed, not a serial number.
3. Or generate the numbers by pattern. If you'd rather not type numbers, the tool auto-generates missing sheet numbers and names from a token template — {i} for the row index, {start} / {n} for a sequential number with zero-padding ({n:000} → 001, 002…), {row.Set}, and parameter tokens — starting from a number you set. Excel-first or pattern-first, your choice.
4. Pick the title block once. Choose a title block type in the window and it applies to every created sheet; choose None and the tool creates real sheets with no title block (not placeholders). Whatever you pick can also be preset in the Excel Title Block field.
5. Preview and validate before anything is written. The grid shows every sheet with a status before you commit — numbers that already exist, blank rows, and conflicts are flagged. Nothing touches the model until you click Create. This is the step Dynamo doesn't give you.
6. Add the parameter columns you need. Beyond the Excel columns, you can add or remove sheet-parameter columns in the window and fill them per row; on create, each value is written to that parameter on each sheet — best-effort, with a per-sheet note if a parameter is missing or read-only.
7. Create — real sheets, one transaction each. Create Sheets makes a real sheet per row, sets the number then the name, writes the parameters, and (optionally) replicates a template sheet's viewports and schedules onto each new sheet. Each sheet is its own transaction, so one bad row is skipped and reported — it never rolls back the whole batch.
8. Land them in a print set. Give the Print Set a name and the created sheets are added to a new Revit print/publish set in the same run — the "…to sheet set" finish. It creates a new set; if the name already exists it tells you and leaves the existing one untouched.
9. Stamp the same list across many open models. With several models open, Create Sheets can run the same sheet list against all of them in one click, resolving — and loading where missing — the chosen title block in each model. The standard sheet set, applied to every model in a federation, from one dialog.

It's the whole job — create, number, fill, organize, place — from the Excel list you already keep, with a preview in front of the write instead of a red graph after it. And because it reads and writes a plain .xlsx, the sheet index stays in the format your project manager already emails around.

Two neighbours in the same free Documentation set finish the workflow: Place on Existing Sheet drops views onto sheets you've already made, and Sync Sheet Issue Date keeps issue dates consistent across a set once the sheets are issued. And if you run a health check before every delivery, the sheet set is one of the things worth auditing — see the companion Revit model health check walkthrough.

FAQ

Can Revit create sheets from Excel? Not on its own — stock Revit has no Excel import for sheets. You can type numbers and names quickly in a Sheet List schedule (which creates placeholder sheets), read an Excel file with a Dynamo graph, or use a tool like B45 Labs Create Sheets that imports an .xlsx sheet index directly into a preview and creates real sheets from it.

What's the fastest way to create many sheets in vanilla Revit? The Sheet List schedule. View → Schedules → Sheet List, then insert new data rows and type numbers and names in the grid. It's far faster than the New Sheet dialog for numbering — but the rows are placeholder sheets that carry no title block and hold no views, so you convert each to a real sheet afterward.

Should I use Dynamo to create sheets? If you already have a working graph, it's a one-off, or you need custom logic — yes, Dynamo is a fine choice. The costs are version fragility (graphs break on Revit upgrades), package dependencies, no built-in preview or validation, and someone having to maintain the graph. For a repeatable, team-wide workflow, a purpose-built tool usually wins.

Do the created sheets get a title block? Yes. You pick one title block type that applies to every sheet, or choose "None" to create real sheets with no title block. The tool creates real sheets, not placeholders, so you can place views on them immediately.

Can I put the new sheets into a print set automatically? Yes. Name a print set and the created sheets are added to a new Revit print/publish set in the same run — the "Excel to sheet set" finish. It creates a new set; if the name already exists it reports that and leaves it alone.

Get the free tool

Create Sheets is part of B45 Labs — a free Revit add-in suite, 50+ commands, no credit card. It's free until 2027 — guaranteed.

• Download free: b45labs.com/download
• Join the founding list to get release updates and workflow guides as they ship.

The sheet index already lives in a spreadsheet. Stop retyping it into Revit one dialog at a time — read the list, preview it, and let the set build itself.