Revit is the industry standard for Building Information Modeling (BIM), yet many teams struggle to control the quality and consistency of the data they embed in their models. Without a systematic approach to data fields, project parameters can multiply uncontrollably, creating silos of information that cannot be compared across disciplines or reused in future work. Shared Parameters offer a disciplined solution: they provide a single source of truth for custom data fields that travels with families and projects, enabling reliable schedules, consistent tagging, and seamless collaboration.

What Are Shared Parameters?

A Shared Parameter is a user‑defined data field stored in an external text file with the .txt extension. Unlike a project parameter—which exists only inside the current project—or a family parameter—which remains within a single family file—a Shared Parameter is designed for reuse across any number of families, projects, and worksets. The shared parameter file acts as a central registry: it defines the parameter’s name, discipline, type (e.g., text, length, number, yes/no), and a globally unique identifier (GUID). Once created, that GUID follows the parameter wherever it is loaded, ensuring that Revit recognizes the data field as the same “thing” regardless of the context.

This external file can be placed on a network drive, a cloud folder, or a BIM 360 shared location, making it available to the entire team. When a user loads the shared parameter into a family or project, Revit reads the GUID from the file to add a consistent data slot. If two different families both contain the same shared parameter, Revit can schedule them together—even if those families belong to different categories and were created by different team members.

Shared Parameters vs. Project Parameters vs. Family Parameters

To appreciate the value of shared parameters, it helps to clearly distinguish the three types of Revit parameters:

  • Family parameters are defined inside a family file (.rfa) and are only available within that family. They cannot be added to a project schedule unless they are shared.
  • Project parameters are defined inside a project (.rvt) and are available only to that project. They cannot be carried into other projects or families without re‑creating them.
  • Shared parameters are defined in an external file and can be added to any family or project. The same shared parameter can be used in multiple families and multiple projects, enabling cross‑project and cross‑discipline reporting.

Because shared parameters are identified by their GUID rather than their name, renaming a shared parameter in the file does not break existing families or projects that already contain that parameter—Revit simply shows the new name. This resilience makes shared parameters the recommended choice for any data field that will be used in schedules, tags, or analysis across more than one project.

The Business Case for Shared Parameters

Adopting shared parameters is not just a technical preference—it is a strategic data management decision. Teams that rely solely on project parameters often find themselves manually re‑entering the same data fields in every new project, leading to inconsistencies and wasted time. Shared parameters solve these problems directly.

  • Consistency across the portfolio: When every project uses the same shared parameters for attributes like “Fire Rating,” “Manufacturer,” “Warranty Duration,” or “Panel Schedule,” the resulting schedules and reports follow a uniform format. This consistency enables portfolio‑wide analysis, facility management handover, and accurate cost estimation.
  • Reusability reduces redundant work: Once a shared parameter is created and loaded into a family template, every new instance of that family automatically carries the data field. Similarly, loading a shared parameter into a project template means every new project starts with the needed fields already available.
  • Interoperability and data exchange: Shared parameters are crucial for exporting to COBie, IFC, or other standards. Both COBie and IFC rely on specific parameter mappings; having those parameters available as shared parameters ensures the export scripts find the correct fields every time.
  • Auditability and quality control: Because shared parameters are stored in a central file, the BIM manager can control which parameters exist, what their data types are, and how they are grouped. This prevents team members from creating ad‑hoc project parameters with inconsistent names (e.g., “Fire_rating” in one project and “Fire Rtg” in another).

Implementing Shared Parameters: A Step‑by‑Step Guide

Setting up shared parameters correctly takes some upfront planning, but the payoff is enormous. The following workflow is recommended for any professional or firm that wants to build a trustworthy BIM data environment.

Step 1: Create and Host the Shared Parameter File

The shared parameter file is nothing more than a text file with a specific structure, but Revit provides a built‑in dialog to create and maintain it. Go to the Manage tab, click Shared Parameters, and then click Create. Choose a location that is accessible to all team members who need to load the parameters. For offices using Autodesk Construction Cloud (ACC) or BIM 360, consider storing the file in a project’s document set or in a linked folder that syncs automatically. For local networks, a read‑only folder on a server works well. Ensure that only a designated BIM manager has write permissions to the file to prevent accidental deletion or corruption.

Once the file is created, you can organize parameters into groups (e.g., “Architecture – Doors,” “Structural – Steel,” “MEP – Lighting”). Groups do not affect the GUID but help users find the right parameter when loading it.

Step 2: Define Parameters Thoughtfully

Each shared parameter requires a Name, Discipline, and Type of Parameter. The discipline setting (Common, Structural, Electrical, etc.) controls which categories appear in the family or project after loading; “Common” is the most flexible and works for all categories. Choose a type that matches the data you intend to store: Text for free‑form strings, Length for dimensions, Number for counts or quantities, Yes/No for binary conditions, URL for web links, or Multiline Text for descriptions.

Naming convention is critical. Adopt a standard such as Discipline_ParameterName_DataType (e.g., “ARCH_DoorHardwareSet_Text”) or a simpler convention like “DoorHardwareSet.” The key is to be consistent and to avoid abbreviations that confuse junior team members. Also, document the naming standard in a central BIM execution plan.

Step 3: Load Shared Parameters into Families

To make a shared parameter available inside a family, open the family (.rfa) and go to the Family Types dialog. Click the Add Parameter button, choose Shared Parameter, and select the desired parameter from the file. You can then associate it with an existing group (Dimensions, Text, etc.) and decide whether it should be an instance parameter (each element can have a different value) or a type parameter (all elements of that type share the same value). For most data‑tracking purposes, instance parameters are preferred because they allow unique values per element.

After adding the parameter, save the family and load it into your project template or directly into the project. When you load the family, Revit asks whether to load the shared parameter as well—always say yes. If the parameter already exists in the project (from another family), Revit matches them by GUID and no duplicate is created.

Step 4: Apply Shared Parameters in Projects

Even if a family already carries the shared parameter, you may need to add it to other elements that do not belong to that family. For example, you might want a “Panel Schedule” parameter for all electrical panels, some of which come from different families. In the project, go to Manage > Project Parameters > Add, choose Shared Parameter, select the parameter, and then check the relevant categories (e.g., “Electrical Equipment,” “Lighting Fixtures”). This adds the parameter to those categories so you can populate values via schedules or instance properties.

Once shared parameters are in the project, create schedules that display them. Use conditional formatting to highlight missing data. Export the schedule to Excel or link it to an external database for further analysis. Because the parameters are shared, the schedule can combine information from walls, doors, furniture, and MEP equipment in a single table—something that would be impossible with project parameters alone.

Advanced Strategies for Data Management

Beyond basic implementation, shared parameters enable several advanced workflows that elevate your data management from good to exceptional.

Naming Conventions and Parameter Groups

The shared parameter file allows infinite grouping. Consider creating groups that mirror your company’s discipline structure (e.g., “AR – Architectural,” “ST – Structural,” “ME – Mechanical”) and within each group, subgroup by element type. This organization speeds up the process of finding and loading the right parameter, especially as the file grows to hundreds or thousands of entries. Also, include a group called “Common – All Disciplines” for parameters like “AssetTag” or “ModelNumber” that every discipline uses.

Use a prefix or suffix convention that makes the data type obvious. For example:

  • TXT_ for text parameters (e.g., TXT_Manufacturer)
  • NUM_ for numbers (e.g., NUM_PanelLoad)
  • BOOL_ for Yes/No (e.g., BOOL_IsFireRated)

Document the convention and enforce it through the BIM manager’s edit rights to the shared parameter file.

Integrating with Autodesk Construction Cloud (ACC) / BIM 360

Shared parameters can be stored in a BIM 360 Document Management folder, allowing teams in different geographic locations to access the same file without setting up a VPN or network drive. However, because Revit reads the file locally, each user must have the file synced to their local drive—either manually or via the Desktop Connector. For large enterprise deployments, consider using the Shared Parameter Service available through the Autodesk Revit or BIM 360 API to programmatically manage parameters across projects.

When using BIM 360 with Cloud Worksharing, shared parameters behave identically to local projects—the GUID system ensures that even if the file path differs between users, Revit matches parameters correctly as long as the GUID remains the same. Always ensure the team uses the same version of the shared parameter file to avoid GUID mismatches caused by editing and re‑creating parameters instead of renaming them.

Using Shared Parameters with Dynamo and the Revit API

For advanced automation, shared parameters are the backbone of any data workflow using Dynamo or Python scripts. Because Dynamo can read and write shared parameter values, you can:

  • Automatically populate parameters from an Excel spreadsheet or CSV file.
  • Export schedules to a database or a Power BI dashboard.
  • Create quality‑control scripts that check for missing or invalid parameter values.
  • Migrate parameters from one shared parameter file to another while preserving GUIDs.

One caution: when using Dynamo to create new shared parameters on the fly, make sure the parameters are added to the central shared parameter file first, not created locally in the project. Otherwise, the GUID generated by Dynamo might not match the firm’s standard, causing duplication. Always use the Revit API or Dynamo nodes that interact with the shared parameter file directly.

Common Pitfalls and How to Avoid Them

Even experienced Revit users sometimes stumble when managing shared parameters. Awareness of these common mistakes can save hours of cleanup.

  • Accidental duplication: When the shared parameter file has not been updated, two users might create the same logical parameter with different names. Always communicate changes to the file, and use the BIM manager as a gatekeeper.
  • Parameter type mismatch: Changing a parameter from “Text” to “Number” after it has been loaded into families can break schedules. If a type change is unavoidable, rename the parameter and create a new one, then update families through a coordinated rollout.
  • Path issues with BIM 360: Users who do not sync the shared parameter file via Desktop Connector might be working with an old copy. Establish a routine of syncing before opening Revit.
  • Too many shared parameters: In an effort to be comprehensive, some teams create thousands of shared parameters, which becomes unmanageable. Instead, start with the parameters required for your current projects and add only as needed.
  • Neglecting family templates: If you only add shared parameters to individual families and not to your template families (.rft), future families will not carry the parameters. Update all company family templates to include the standard shared parameters.

Best Practices for Long‑Term Success

Shared parameters are not a “set once and forget” tool. To maintain a healthy data ecosystem, adopt these long‑term practices:

  • Appoint a shared parameter custodian: This person approves all new parameters, ensures naming conventions are followed, and periodically audits the file for redundancy.
  • Maintain a changelog: Keep a simple spreadsheet or document that records when a parameter was added, modified, or retired. Share it with the team so everyone knows what changed.
  • Use project templates with preloaded parameters: Add all standard shared parameters to your project template (.rte) so they are available immediately. This eliminates the need to load them project by project.
  • Train the team on disciplined data entry: A well‑defined parameter structure is useless if team members leave values blank or enter incorrect data. Provide clear guidelines and use Revit’s “Required” or “Read‑Only” options where applicable.
  • Leverage schedules as validation tools: Create schedules that show only the elements with missing critical data (e.g., “Door Hardware Set is empty”). Use conditional formatting to flag red cells. This makes data quality visible at a glance.
  • Plan for export to facility management: If your firm delivers Asset Information Models (AIM) or COBie, map your shared parameters to the required fields in advance. Many FM‑related parameters (like “Serial Number,” “Warranty Start Date”) should be shared parameters from day one.

Conclusion

Shared Parameters are one of the most powerful yet underutilized features in Revit. By providing a persistent, reusable, and universally identified way to store data, they transform BIM models from simple geometry with a few text notes into structured, queryable databases. Teams that invest the time to design a lean, well‑organized shared parameter file see immediate returns in schedule accuracy, cross‑discipline coordination, and streamlined data handover to downstream users.

Start small: identify the five most frequently used custom data fields in your current projects and convert them into shared parameters. Load them into your family and project templates. Then gradually expand the library as your needs grow. With careful governance and the right automation tools—such as Dynamo scripts or the official Revit Shared Parameter documentation—your team will achieve the kind of data consistency that higher‑level BIM workflows demand.

Remember that shared parameters are not merely a technical feature; they are a collaborative agreement about what data matters and how it should be captured. When every participant in the building lifecycle—designers, engineers, contractors, and owners—agrees on a shared vocabulary, the entire project benefits from fewer errors, faster decision‑making, and a smoother transition from design to operations.