Check if the Revit MCP API is active and responding

Get comprehensive information about the current Revit model

Export a specific Revit view as an image

Get a list of all exportable views in the current Revit model

Get detailed information about the currently active view in Revit.

Returns comprehensive information including:

• View name, type, and ID

• Scale and detail level

• Crop box status

• View family type

• View discipline

• Template status

Get all elements visible in the currently active view in Revit.

Returns detailed information about each element including:

• Element ID, name, and type

• Category and category ID

• Level information (if applicable)

• Location information (point or curve)

• Summary statistics grouped by category

This is useful for understanding what elements are currently visible and analyzing the content of the active view.

Place a family instance at a specified location in the Revit model

Get a flat list of available family types in the current Revit model

Get a list of all family categories in the current Revit model

Get a list of all levels in the current Revit model

Color elements in a category based on parameter values

This tool applies color coding to Revit elements within a specified category based on their parameter values. Elements with the same parameter value will receive the same color.

Args: category_name: Name of the category to color (e.g., "Walls", "Doors", "Windows") parameter_name: Name of the parameter to use for coloring (e.g., "Mark", "Type Name") use_gradient: Whether to use gradient coloring instead of distinct colors (default: False) custom_colors: Optional list of custom colors in hex format (e.g., ["#FF0000", "#00FF00"]) ctx: MCP context for logging

Returns: Results of the coloring operation including statistics and color assignments

Clear color overrides for elements in a category

This tool removes all color overrides that have been applied to elements in the specified category, returning them to their default appearance.

Args: category_name: Name of the category to clear colors from (e.g., "Walls", "Doors") ctx: MCP context for logging

Returns: Results of the clear operation including count of elements processed

Get available parameters for elements in a category

This tool helps you discover what parameters are available for coloring by listing all parameters found on elements in the specified category.

Args: category_name: Name of the category to check parameters for (e.g., "Walls", "Doors") ctx: MCP context for logging

Returns: List of available parameters with their types and sample values

Execute IronPython code directly in Revit context.

This tool allows you to send IronPython 2.7.12 code to be executed inside Revit. The code has access to:

• doc: The active Revit document

• DB: Revit API Database namespace

• revit: pyRevit module

• print: Function to output text (returned in response)

Use this when the existing MCP tools cannot accomplish what you need.

Args: code: The IronPython code to execute (as a string) description: Optional description of what the code does ctx: MCP context for logging

Returns: Execution results including any output or errors

Example: code = ''' # encoding: utf-8 # Hello World example print("Hello from Revit!") from pyrevit import revit, DB, forms, script output = script.get_output() output.close_others() doc = revit.doc print("Document title:", doc.Title) print("Number of walls:", len(list(DB.FilteredElementCollector(doc).OfCategory(DB.BuiltInCategory.OST_Walls).WhereElementIsNotElementType()))) collector = DB.FilteredElementCollector(doc).OfClass(DB.TextNoteType).ToElements() print("Number of text note types:", len(collector)) '''

Tips for writing IronPython code in Revit:

1. Accessing Element.Name property: Some Revit elements don't expose the 'Name' property directly in IronPython. Use defensive access patterns:

   Option 1: Use getattr with a default value

   name = getattr(element, 'Name', 'N/A')

   Option 2: Use try-except

   try: name = element.Name except AttributeError: name = 'Unable to retrieve name'

   Option 3: Use BuiltInParameter for element types

   param = element_type.get_Parameter(DB.BuiltInParameter.ALL_MODEL_TYPE_NAME) name = param.AsString() if param else 'N/A'

2. Always check if elements exist before accessing properties: element = doc.GetElement(element_id) if element: # Safe to access element properties

3. Use hasattr() before accessing optional properties: if hasattr(element_type, 'FamilyName'): family_name = element_type.FamilyName

4. The Tool already wraps the code around a transaction.

Create walls, beams, and other line-based building elements in Revit.

Each element needs start and end points (in millimeters), element type (wall/beam), and optionally a level name, height, and family type name. Supports batch creation — pass multiple elements in one call.

Args: elements: List of element definitions, each with: - element_type (str): "wall" or "beam" (required) - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - type_name (str): Family type name, e.g. "Generic - 200mm" (optional) - level_name (str): Target level name (optional, defaults to first level) - height (float): Element height in mm (optional, defaults to 3000) - offset (float): Offset from base level in mm (optional, defaults to 0) - structural (bool): Mark as structural (optional, defaults to false) - name (str): Description for reference (optional) ctx: MCP context for logging

Create floors, roofs, ceilings, and other surface-based building elements.

Each element needs a closed boundary polygon (list of line segments) where the last point connects back to the first. All dimensions in millimeters. Supports batch creation.

Args: elements: List of element definitions, each with: - element_type (str): "floor", "roof", or "ceiling" (required) - boundary (list[dict]): Array of {"p0": Point, "p1": Point} segments forming a closed polygon (required, minimum 3 segments) - type_name (str): Family type name (optional) - level_name (str): Target level name (optional) - offset (float): Offset from level in mm (optional, defaults to 0) - name (str): Description for reference (optional) ctx: MCP context for logging

Create building levels (floor elevations) in Revit.

Levels define the floor-to-floor heights of a building and must be created before placing walls, floors, or other level-dependent elements.

Args: levels: List of level definitions, each with: - elevation (float): Elevation in mm from project origin (required) - name (str): Level name, e.g. "Ground Floor" (optional, auto-assigned) ctx: MCP context for logging

Delete one or more elements from the Revit model.

Removes elements by their IDs. If a deleted element hosts other elements (e.g., a wall with doors), the hosted elements are also deleted (cascade). All deletions happen in a single transaction — if any fails, none are deleted.

Args: element_ids: List of Revit element IDs to delete ctx: MCP context for logging

Modify parameter values on a Revit element.

Changes one or more instance parameters on the specified element. Returns old and new values for confirmation.

Args: element_id: Revit element ID to modify parameters: Dictionary of parameter name to new value pairs e.g., {"Mark": "EW-01", "Comments": "Updated via MCP"} ctx: MCP context for logging

Get details of elements currently selected in the Revit UI.

Returns IDs, categories, types, and key parameters of all elements the user has selected in Revit. Returns an empty list if nothing is selected (not an error).

Args: ctx: MCP context for logging

Create grid lines for the structural layout of a building.

Grids define the column grid system. Each grid is a line from start to end point (in millimeters). Names auto-assign (A, B, C... or 1, 2, 3...) if not provided. Supports batch creation.

Args: grids: List of grid definitions, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - name (str): Grid line name (optional, auto-assigned) ctx: MCP context for logging

Create structural beams and framing elements in Revit.

Beams are placed along a line between two points at a specified level. All dimensions in millimeters. Supports batch creation.

Args: elements: List of beam definitions, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - type_name (str): Beam family type name (optional) - level_name (str): Target level name (optional) - name (str): Description for reference (optional) ctx: MCP context for logging

Create dimension annotations for elements in the current view.

Automatically dimensions the specified elements. Works in plan, section, and elevation views. The dimension line is placed at an offset from the elements for readability.

Args: element_ids: List of element IDs to dimension dimension_type: Type of dimension — "linear", "aligned", or "angular" (defaults to "linear") ctx: MCP context for logging

Tag all untagged walls in the current Revit view.

Places wall tags on every wall visible in the active view that doesn't already have a tag. Tags are centered on each wall segment.

Args: use_leader: Whether to show leader lines (defaults to False) tag_type_name: Specific wall tag family type name (optional, uses first available) ctx: MCP context for logging

Filter and find Revit elements by category, type, visibility, and spatial bounds.

A powerful query tool for finding specific elements in the model. Combine filters for precise results — e.g., find all exterior walls on Level 1 visible in the current view.

Args: category: BuiltInCategory name, e.g. "OST_Walls", "OST_Doors" (optional) type_name: Filter by family type name or partial match (optional) visible_in_view: Only include elements visible in the active view (optional) bounding_box_min: Spatial filter min corner {"x", "y", "z"} in mm (optional) bounding_box_max: Spatial filter max corner {"x", "y", "z"} in mm (optional) max_elements: Maximum results to return (defaults to 50) ctx: MCP context for logging

Export data for all rooms defined in the Revit model.

Returns room names, numbers, levels, areas, perimeters, and departments in a structured format suitable for analysis and reporting.

Args: ctx: MCP context for logging

Get material quantities (areas and volumes) from the Revit model.

Returns aggregated material data across all elements, optionally filtered by category. Useful for quantity takeoffs and cost estimation.

Args: categories: List of categories to include, e.g. ["OST_Walls", "OST_Floors"] (optional, defaults to all categories) ctx: MCP context for logging

Analyze the Revit model and return element counts grouped by category.

Provides a high-level overview of what's in the model — how many walls, doors, windows, floors, etc. Useful for progress tracking and model health checks.

Args: ctx: MCP context for logging

Create a drawing sheet in Revit for construction documentation.

Sheets are the printable output of a Revit project. Each sheet has a title block, sheet number, and name. Views can be placed on sheets after creation.

Args: sheet_number: Sheet number, e.g. "A101" (optional, auto-assigned) sheet_name: Sheet title, e.g. "Ground Floor Plan" (defaults to "Unnamed Sheet") title_block_name: Title block family name (optional, uses first available) ctx: MCP context for logging

Create a schedule (quantity takeoff view) for a specific element category.

Schedules tabulate element data — e.g., a wall schedule showing all walls with their types, lengths, and areas. The schedule appears as a new view in the Revit project browser.

Args: category: BuiltInCategory name, e.g. "OST_Walls", "OST_Rooms" (required) fields: Parameter names to include as columns (optional, uses default set) e.g., ["Family and Type", "Length", "Area", "Mark"] schedule_name: Name for the schedule view (optional, auto-generated) ctx: MCP context for logging

Export a Revit view or sheet to PDF or image format.

Exports the specified view (or the active view if none specified) to a file on disk. Supported formats: PDF, PNG, JPG, DWG.

Args: view_name: Name of the view or sheet to export (optional, uses active view) format: Output format — "pdf", "png", "jpg", or "dwg" (defaults to "pdf") resolution: DPI for image formats (defaults to 300, ignored for PDF/DWG) ctx: MCP context for logging

Create a room in the Revit model at a specified level.

Rooms must be placed inside enclosed areas (bounded by walls or room separation lines). If no location is given, Revit auto-places the room.

Args: level_name: Target level name (e.g., "Level 1") location: Optional placement point {"x": float, "y": float} in mm name: Room name (e.g., "Living Room") number: Room number (e.g., "101") ctx: MCP context for logging

Create room separation lines to define room boundaries.

Room separation lines act as invisible walls for room calculation. Use these when physical walls don't fully enclose a space (e.g., open-plan areas, corridors). All coordinates in millimeters.

Args: lines: List of line segments, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm - end_point (dict): {"x": float, "y": float, "z": float} in mm level_name: Target level name (defaults to active view's level) view_name: Plan view name (defaults to active view) ctx: MCP context for logging

Create a new view in the Revit model.

Supports floor plans, ceiling plans, sections, elevations, and 3D views. Floor plans and ceiling plans require a level name. Sections require a section box definition with origin, direction, and dimensions.

Args: view_type: Type of view — "floor_plan", "ceiling_plan", "section", "elevation", or "3d" name: Display name for the new view level_name: Required for floor_plan and ceiling_plan — the level to show section_box: Required for section — defines the cut plane: - origin (dict): {"x", "y", "z"} center point in mm - direction (dict): {"x", "y", "z"} view direction vector - up (dict): {"x", "y", "z"} up direction vector - width (float): Section width in mm - height (float): Section height in mm - depth (float): Section depth in mm ctx: MCP context for logging

Switch the active view in Revit to the specified view.

Changes which view is displayed in the Revit UI. Use list_revit_views first to find available view names.

Args: view_name: Name of the view to activate ctx: MCP context for logging

Tag elements with annotation symbols in a view.

Places tags on the specified elements. Tags display element properties like type name, mark, or room name/number. Works with walls, doors, windows, rooms, and other taggable categories.

Args: element_ids: List of element IDs to tag view_name: View to place tags in (defaults to active view) tag_type_name: Tag family type name (auto-detects appropriate tag if omitted) add_leader: Show leader line from tag to element (default: false) orientation: Tag orientation — "horizontal" or "vertical" (default: "horizontal") offset: Tag offset from element center {"x": float, "y": float} in mm ctx: MCP context for logging

Move, copy, rotate, or mirror elements in the Revit model.

Performs geometric transformations on one or more elements. All coordinates and distances are in millimeters, angles in degrees.

Args: element_ids: List of element IDs to transform operation: Transform type — "move", "copy", "rotate", or "mirror" vector: Translation vector {"x", "y", "z"} in mm (required for move/copy) axis_point: Rotation center {"x", "y", "z"} in mm (required for rotate) angle: Rotation angle in degrees (required for rotate) mirror_plane: Mirror definition (required for mirror): - origin (dict): {"x", "y", "z"} point on the mirror plane in mm - normal (dict): {"x", "y", "z"} plane normal direction ctx: MCP context for logging

Create a duct in the Revit model between two points.

Requires a project with mechanical families loaded (MEP template). Specify diameter for round ducts, or width+height for rectangular. All dimensions in millimeters.

Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm system_type: System type name (e.g., "Supply Air"). Auto-detects if omitted duct_type: Duct type name (e.g., "Round Duct"). Auto-detects if omitted level_name: Level name. Defaults to nearest level diameter: Round duct diameter in mm width: Rectangular duct width in mm height: Rectangular duct height in mm ctx: MCP context for logging

Create a pipe in the Revit model between two points.

Requires a project with plumbing families loaded (MEP template). All dimensions in millimeters.

Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm system_type: System type name (e.g., "Domestic Hot Water"). Auto-detects if omitted pipe_type: Pipe type name (e.g., "Copper"). Auto-detects if omitted level_name: Level name. Defaults to nearest level diameter: Pipe diameter in mm ctx: MCP context for logging

Create a mechanical or piping system and optionally add elements to it.

Groups ducts or pipes into a named system for organization and analysis.

Args: system_type: "mechanical" or "piping" system_name: Display name for the system (e.g., "Level 1 Supply Air") element_ids: Optional list of duct/pipe element IDs to add to the system ctx: MCP context for logging

Get all properties and parameters of a Revit element.

Returns the element's category, family, type, and a complete list of both instance and type parameters with their values, storage types, and read-only status.

Args: element_id: Revit element ID to inspect include_type_params: Include type parameters in addition to instance parameters (default: true) ctx: MCP context for logging

Set a single parameter value on a Revit element.

Automatically detects the parameter's storage type (String, Integer, Double, ElementId) and converts the value accordingly. Returns old and new values for confirmation.

Args: element_id: Target element ID parameter_name: Name of the parameter to set (e.g., "Comments", "Mark") value: New value as a string — automatically converted to the correct type ctx: MCP context for logging

Export the Revit model to IFC format.

Creates an IFC file at the specified path. Optionally filter by view to export only visible elements. Supports IFC2x3 and IFC4.

Args: file_path: Output file path (must end in .ifc) ifc_version: "IFC2x3" (default) or "IFC4" export_base_quantities: Include IFC base quantities (default: true) view_name: Export only elements visible in this view (optional) ctx: MCP context for logging

Link or import an external file into the Revit model.

Supports DWG, DXF, DGN (CAD files) and RVT (Revit links). Linked files maintain a live connection; imported files are embedded.

Args: file_path: Path to the file (DWG, DXF, DGN, or RVT) mode: "link" (default, maintains connection) or "import" (embeds copy) position: Optional placement offset {"x", "y", "z"} in mm ctx: MCP context for logging

Create a detail line in a Revit view for annotation purposes.

Detail lines are view-specific 2D annotation elements. They only appear in the view where they are created (unlike model lines). Must be created in a plan, section, or detail view.

Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm view_name: Target view name (defaults to active view) line_style: Line style name (e.g., "Medium Lines"). Uses default if omitted ctx: MCP context for logging