# ETABS MCP (pypi · etabs-mcp)

Agentic MCP server for CSI ETABS v22+: model, load, analyse, design and inspect structures.

- Trust score: 60/100 (medium)
- Change this week: −20
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `etabs-mcp`: 60/100 (this document), [markdown](https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp.md), [page](https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp)

## Channel facts

- Registry: `pypi`
- Package: `etabs-mcp`
- Version: `0.3.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 0 of 35 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 71/100
  - Repository check failed: the declared repository URL returned HTTP 404.
  - Cryptographically verified build provenance (signed, bound to Moha2005269/etabs-mcp).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 18 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7975 tokens (~109/item across 73 items; 71 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 87/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 55% of tool parameters carry a description.
  - Structured output schemas are declared (97% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 73 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the ETABS MCP server?

ETABS MCP runs locally as a PyPI package, launched with uvx etabs-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add moha2005269-etabs-mcp -- uvx etabs-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "moha2005269-etabs-mcp": {
      "command": "uvx",
      "args": [
        "etabs-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "moha2005269-etabs-mcp": {
      "command": "uvx",
      "args": [
        "etabs-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add moha2005269-etabs-mcp -- uvx etabs-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "moha2005269-etabs-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "etabs-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add moha2005269-etabs-mcp --command uvx --arg etabs-mcp
```

### Hermes

```yaml
mcp_servers:
  moha2005269-etabs-mcp:
    command: "uvx"
    args: ["etabs-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "moha2005269-etabs-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "etabs-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add moha2005269-etabs-mcp -t stdio -c uvx -a etabs-mcp
```

### Other

```json
{
  "mcpServers": {
    "moha2005269-etabs-mcp": {
      "command": "uvx",
      "args": [
        "etabs-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 60, −20)

- [security regression] Malware scan: pass → unverified
- [security regression] Source repository: pass → fail
- [functional regression] Security disclosure: fail → unverified

### 2026-10-29 (score 80, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-18 (score 65)

First indexed and scored.

## MCP tools (71)

### `etabs_list_installations` (~34 tokens)

List ETABS installations on this machine (v22+ are supported) and ETABS instances that are running now.

### `etabs_connect` (~223 tokens)

Connect to ETABS. Other tools connect automatically with mode 'auto', so call this only to choose a
specific instance or version, to drive several ETABS instances, or to recover after ETABS was closed.
Launching ETABS takes 10-30 s.

Input parameters:

- `install_dir`: ETABS program folder, overrides 'version'.
- `instance` (string): Name for this connection. Use a new name (e.g. 'b') to drive a second ETABS alongside the first; it becomes the active instance.
- `mode` (string): attach = use a running ETABS; start = launch a new one; auto = attach if one is running, else start.
- `pid`: Attach to this ETABS process id (see etabs_list_installations).
- `reconnect` (boolean): Drop the current connection first.
- `version`: ETABS major version to use, e.g. 22 or 23. Default: the running one, else the newest installed.
- `visible` (boolean): Show the ETABS window when launching it.

### `etabs_instances` (~100 tokens)

List the ETABS instances this server drives, switch which one every other tool acts on, or remove one.
Typical use: compare two design options side by side, or copy data from one model into another.

Input parameters:

- `action` (string)
- `close_etabs` (boolean): 'remove' only: also exit that ETABS (needs confirm).
- `confirm` (boolean)
- `name`: Instance for 'use' or 'remove'.

### `etabs_status` (~45 tokens)

Connection and model status without connecting: whether ETABS is attached, its version, the open
model file, present units, and whether the model is locked (has analysis results).

### `etabs_disconnect` (~73 tokens)

Release the ETABS connection. ETABS keeps running unless close_etabs is true.

Input parameters:

- `close_etabs` (boolean): Also exit the ETABS application.
- `confirm` (boolean): Required when closing ETABS without saving.
- `save` (boolean): Save the model before exiting (only with close_etabs).

### `etabs_model_overview` (~52 tokens)

One-call summary of the open model: file, version, units, lock state, object counts, stories,
load patterns/cases/combinations, materials, sections and groups. Start every task with this.

### `etabs_new_model` (~202 tokens)

Start a new model (replaces the open one). Lengths are in the chosen units.

Input parameters:

- `bottom_story_height`: Number in the new model's units or e.g. '6 m'.
- `confirm` (boolean): Required when the current model has objects: it is replaced without saving.
- `grid_lines_x` (integer)
- `grid_lines_y` (integer)
- `number_of_stories` (integer)
- `spacing_x`: Number in the new model's units or e.g. '6 m'.
- `spacing_y`: Number in the new model's units or e.g. '6 m'.
- `template` (string): blank = empty model; grid_only = grids + stories; steel_deck = grids, stories and a steel floor system.
- `typical_story_height`: Number in the new model's units or e.g. '6 m'.
- `units` (string): Units for the new model.

### `etabs_open_model` (~85 tokens)

Open an existing ETABS model file (.EDB, or an importable .e2k text file). Replaces the open model.

Input parameters:

- `confirm` (boolean): Required when the current model has objects: it is closed without saving.
- `path` (string, required): Full path of an .EDB (or importable .e2k/.$et) file.

### `etabs_save_model` (~53 tokens)

Save the model. A new (untitled) model needs a path. Analysis also requires a saved model.

Input parameters:

- `path`: Save as this .EDB path. Omit to save to the current file.

### `etabs_set_units` (~32 tokens)

Set the present units. All tool inputs and outputs use the present units.

Input parameters:

- `units` (string, required)

### `etabs_get_stories` (~30 tokens)

Story table, top story first: name, elevation, height, master/similar settings.

### `etabs_set_stories` (~56 tokens)

Redefine the story table. ETABS only accepts this on a model without objects on the affected stories.

Input parameters:

- `base_elevation`
- `stories_bottom_up` (array, required): Stories from the lowest to the highest.

### `etabs_add_frames` (~70 tokens)

Draw beams, columns and braces between two points (like Draw > Frame). Joints are created or merged
automatically. Returns the ETABS names of the new frames, in input order; failures are listed per item.

Input parameters:

- `csys` (string)
- `frames` (array, required)

### `etabs_add_areas` (~48 tokens)

Draw floors, slabs and walls from corner points (like Draw > Floor/Wall). Returns new area names.

Input parameters:

- `areas` (array, required)
- `csys` (string)

### `etabs_add_points` (~39 tokens)

Add joints at coordinates (existing joints at the same location are reused).

Input parameters:

- `csys` (string)
- `points` (array, required)

### `etabs_list_objects` (~107 tokens)

List frames, areas or points with their geometry (in present units), sections and stories.
ETABS 'name' is the unique name used by every API call; 'label' is what the GUI shows per story.

Input parameters:

- `include_labels` (boolean): Add the label and story of each object (one extra call per object).
- `kind` (string, required)
- `limit` (integer)
- `offset` (integer)
- `story`: Only objects on this story.

### `etabs_delete_objects` (~72 tokens)

Delete frames, areas or points chosen by name, by group, or the current selection.

Input parameters:

- `confirm` (boolean): Deleting cannot be undone through the API. Ask the user first.
- `group`
- `kind` (string, required)
- `names`
- `selected` (boolean)

### `etabs_set_restraints` (~143 tokens)

Assign supports (Assign > Joint > Restraints): fixed, pinned, roller or custom DOFs, to joints chosen by
name, by elevation, by group, or the current selection.

Input parameters:

- `at_elevation`: Apply to every joint at this Z, e.g. 0 or '0 m'.
- `dofs`: [UX, UY, UZ, RX, RY, RZ] for 'custom'.
- `group`
- `points`: Joint names.
- `restraint` (string): Support type; 'custom' uses 'dofs'.
- `selected` (boolean)
- `tolerance` (number)

### `etabs_assign_section` (~74 tokens)

Assign a frame section or an area property (Assign > Frame > Section / Shell > Property).

Input parameters:

- `group`
- `kind` (string, required)
- `names`
- `section` (string, required): Frame section or area (slab/deck/wall) property name.
- `selected` (boolean)

### `etabs_select` (~90 tokens)

Change or read the selection, like clicking in the ETABS window. Many tools accept selected=true to act
on it. Returns the selected objects grouped by type.

Input parameters:

- `action` (string): 'get' only reports the selection; 'objects' selects 'names' of 'kind'.
- `deselect` (boolean)
- `group`
- `kind`
- `names`

### `etabs_generate_building` (~366 tokens)

Build a complete regular building in one call: grids, stories, materials, sections, columns, beams,
braces or shear walls (with pier labels), slabs, fixed supports, a rigid diaphragm, SDL/LL patterns with
slab loads, and default design combinations. Follow with lateral loads (etabs_define_seismic_load ...),
then analysis.

Input parameters:

- `bays_x` (array, required): Bay widths along X, e.g. ['8 m', '8 m', '6 m'].
- `bays_y` (array, required): Bay widths along Y.
- `beam_section`: Steel: AISC16 shape (default W18X35).
- `beam_size` (array): Concrete beam [depth, width].
- `brace_section`: Steel braced: AISC16 shape (default W10X33).
- `column_section`: Steel: AISC16 shape (default W14X90). Concrete: ignored, use column_size.
- `column_size` (array): Concrete column [depth, width].
- `confirm` (boolean): Required when the open model has objects: it is replaced.
- `diaphragm` (boolean)
- `live`: Live area load in present force/length² units.
- `slab_thickness`
- `story_heights` (array, required): Story heights bottom-up, e.g. ['4.5 m', '3.5 m', '3.5 m'].
- `superimposed_dead`: SDL area load in present force/length² units (e.g. 1.5 for kN/m²).
- `system` (string): Lateral system. Braces/walls go in the end bays of every perimeter frame line.
- `units` (string)
- `wall_thickness`

### `etabs_list_properties` (~46 tokens)

List materials (with type), frame sections (with shape and dimensions in present units) and area
properties (slabs, decks, walls).

Input parameters:

- `kind` (string)

### `etabs_define_material` (~228 tokens)

Define a material, either from the ETABS library (region + standard + grade, the same lists as the
'Add Material' dialog) or as a custom isotropic material from E, weight and strength.

Input parameters:

- `elastic_modulus`: Custom material: E (present force/length^2).
- `fc`: Concrete compressive strength f'c.
- `fu`: Steel/rebar tensile strength (default 1.25 fy).
- `fy`: Steel/rebar yield strength.
- `grade`: Library material: grade, e.g. 'Grade 50', 'C30/37'.
- `material_type` (string, required)
- `name` (string, required)
- `poisson_ratio` (number)
- `region`: Library material: region, e.g. 'United States', 'Europe', 'India'.
- `standard`: Library material: standard, e.g. 'ASTM A992', 'EN 1992-1-1'.
- `thermal_coefficient` (number)
- `unit_weight`: Weight per unit volume (present units).

### `etabs_define_frame_section` (~230 tokens)

Define a frame section: parametric concrete/steel shapes, or a steel shape imported from an ETABS
section library. Dimensions are in present length units.

Input parameters:

- `bottom_flange_thickness`: i_section only; defaults to flange_thickness.
- `bottom_flange_width`: i_section only; defaults to width.
- `depth`: t3: overall depth (rectangle, i_section, tube) or outside diameter (circle, pipe).
- `flange_thickness`
- `library_file`: from_library: section database file, e.g. 'AISC16.xml', 'Euro.xml', 'Indian.xml'.
- `library_section`: from_library: section name in that file, e.g. 'W14X90'.
- `material` (string, required): Material name (see etabs_list_properties).
- `name` (string, required)
- `shape` (string, required)
- `web_thickness`: Web thickness (i_section, tube) or wall thickness (pipe).
- `width`: t2: width (rectangle, tube) or top flange width (i_section).

### `etabs_define_area_section` (~82 tokens)

Define a slab or wall property (Define > Section Properties > Slab/Wall Sections).

Input parameters:

- `kind` (string, required)
- `material` (string, required)
- `name` (string, required)
- `shell_type` (string)
- `slab_type` (string)
- `thickness` (required): Number in present units or e.g. '200 mm'.

### `etabs_define_load_patterns` (~36 tokens)

Define load patterns (Define > Load Patterns), each optionally with its linear static load case.

Input parameters:

- `patterns` (array, required)

### `etabs_assign_loads` (~65 tokens)

Assign loads (Assign > Frame/Shell/Joint Loads): distributed or point loads on frames, uniform loads on
areas, and forces/moments on joints. Values are in present units; 'gravity' acts downward (-Z).

Input parameters:

- `loads` (array, required)

### `etabs_define_combinations` (~74 tokens)

Define load combinations (Define > Load Combinations) from load cases and other combinations, and/or
generate the default design combinations for the active design codes.

Input parameters:

- `add_default_design_combos` (array): Also generate the code default design combinations for these materials.
- `combinations` (array): Combinations to create.

### `etabs_list_load_definitions` (~39 tokens)

Load patterns (with type and self-weight multiplier), load cases (with type) and combinations (with
their cases and scale factors).

### `etabs_define_seismic_load` (~247 tokens)

Define an ASCE 7-16 equivalent-lateral-force seismic load pattern (Define > Load Patterns > Auto
Lateral Load). Creates the Quake pattern and its load case.

Input parameters:

- `bottom_story`: Default: Base.
- `cd` (number): Deflection amplification Cd.
- `ct_type` (integer): Approximate-period Ct/x set (ETABS numbering, 2 = 0.03;0.75 'all other').
- `directions` (array): Directions and accidental eccentricity sense.
- `eccentricity` (number)
- `importance` (number)
- `name` (string)
- `omega` (number): Overstrength factor Ω0.
- `period` (string): Fundamental period source.
- `r` (number): Response modification coefficient R.
- `s1` (number): Mapped MCER 1-s acceleration S1 (g).
- `site_class` (string)
- `ss` (number): Mapped MCER short-period acceleration Ss (g).
- `tl` (number): Long-period transition TL (s).
- `top_story`: Default: the top story.
- `user_period` (number)

### `etabs_define_wind_load` (~260 tokens)

Define an automatic wind load pattern applied to diaphragms (Define > Load Patterns > Auto Lateral
Load > Wind). ASCE 7-16 is fully parameterised; other codes take their table fields via 'fields'.

Input parameters:

- `angle` (number): Wind direction angle in degrees (0 = +X, 90 = +Y).
- `bottom_story`
- `cases` (string): ASCE 7 wind load cases.
- `code` (string): Auto-wind table code suffix, e.g. 'ASCE 7-16', 'ASCE 7-22', 'Eurocode1 2005'. Other codes need 'fields'.
- `exposure` (string)
- `fields`: Extra/override table fields for the chosen code (see etabs_get_table on 'Load Pattern Definitions - Auto Wind - <code>').
- `gust_factor` (number)
- `kd` (number)
- `kzt` (number)
- `leeward_cp` (number)
- `name` (string)
- `top_story`
- `wind_speed` (number): Basic wind speed V (mph for ASCE 7).
- `windward_cp` (number)

### `etabs_define_response_spectrum` (~142 tokens)

Define an ASCE 7-16 response spectrum function and a response-spectrum load case that uses it.

Input parameters:

- `case_name` (string)
- `damping` (number)
- `direction` (string)
- `eccentricity` (number)
- `function_name` (string)
- `importance` (number)
- `modal_case` (string)
- `r` (number)
- `s1` (number)
- `scale_factor`: Default g·I/R in present units (from importance and r).
- `site_class` (string)
- `ss` (number)
- `tl` (number)

### `etabs_set_mass_source` (~81 tokens)

Set the default mass source (Define > Mass Source): element self mass, added mass and load patterns.

Input parameters:

- `include_added_mass` (boolean)
- `include_self_weight` (boolean)
- `loads`: Load patterns that contribute mass, e.g. [{'pattern':'SDL'}, {'pattern':'LL','multiplier':0.25}].

### `etabs_assign_diaphragm` (~66 tokens)

Define a rigid or semi-rigid diaphragm and assign it to the slabs (area objects) on the chosen stories.

Input parameters:

- `name` (string)
- `semi_rigid` (boolean)
- `stories`: Stories to assign (default: all with slabs).

### `etabs_set_modal_case` (~52 tokens)

Set how many modes the eigen modal case computes (raise it until mass participation is enough).

Input parameters:

- `case` (string)
- `max_modes` (integer)
- `min_modes` (integer)

### `etabs_run_analysis` (~129 tokens)

Run the analysis (Analyze > Run Analysis). ETABS needs a saved model, saves it again before running,
and locks the model afterwards. Large models can take minutes: use background=true to avoid client timeouts.

Input parameters:

- `background` (boolean): Return a job id at once and run in the background (for big models or clients with short tool timeouts). Follow with etabs_job_wait / etabs_job_status.
- `cases`: Load cases to run (default: all).
- `save_as`: Save to this .EDB path first. Required for a never-saved model.

### `etabs_analysis_status` (~31 tokens)

Per-case analysis status (not run / finished ...), run flags, and whether the model is locked.

### `etabs_unlock_model` (~50 tokens)

Unlock the model so it can be edited after analysis (the padlock button). Deletes analysis results.

Input parameters:

- `confirm` (boolean): Unlocking deletes all analysis and design results. Ask the user first.

### `etabs_get_results` (~148 tokens)

Read analysis results the way they appear in ETABS tables: base reactions, story drifts and forces,
joint displacements/reactions, modal periods and mass ratios, element forces, piers and spandrels.
For any other result table use etabs_get_table.

Input parameters:

- `group` (string)
- `limit`
- `load_cases`: Load cases to include. Omit both lists for every case and combination.
- `load_combinations`
- `offset` (integer)
- `result` (string, required): Which result table to read.
- `where`: Row filter, e.g. {'Story': 'Story2'} or {'OutputCase': 'Dead'}.

### `etabs_run_design` (~110 tokens)

Run design (Design > ... > Start Design/Check) with the model's current design codes and preferences.
Needs analysis results. Steel and concrete return a member summary, worst first.

Input parameters:

- `background` (boolean): Run as a background job (see etabs_job_wait).
- `kind` (string, required): Shear wall design cannot be started through the ETABS API; read its results with etabs_get_table.
- `summary_limit` (integer): Members to return in the summary, worst first.

### `etabs_job_status` (~67 tokens)

Status of a background job (analysis or design): running / done / failed, elapsed time, the tail of the
ETABS analysis log while it runs, and the full result once done. Never blocks.

Input parameters:

- `job_id`: Job id; omit for the most recent job.

### `etabs_job_wait` (~85 tokens)

Wait for a background job to finish, up to timeout_seconds, then report it (same shape as etabs_job_status).
Call again if it is still running.

Input parameters:

- `job_id`: Job id; omit for the most recent job.
- `timeout_seconds` (number): Give up waiting after this long (the job keeps running). Keep it under your client's tool timeout.

### `etabs_get_design_summary` (~75 tokens)

Design results per member: steel demand/capacity ratios with governing combo, or concrete required
reinforcement for beams and columns. Worst members first.

Input parameters:

- `kind` (string, required)
- `limit` (integer)
- `only_failing` (boolean): Steel: only members with ratio > 1 or errors.

### `etabs_design_codes` (~111 tokens)

Read, list or change the design codes (Design > ... > View/Revise Preferences). 'list' returns every code
this ETABS version supports for steel, concrete, shear wall, slab and composite design.

Input parameters:

- `action` (string)
- `code`: For 'set': e.g. 'AISC 360-16', 'ACI 318-19', 'Eurocode 2-2004'. 'list' shows valid names.
- `kind`: For 'set'.

### `etabs_run_shear_wall_design` (~100 tokens)

Run shear wall design (Design > Shear Wall Design > Start Design/Check) and return pier and spandrel
results. The ETABS API has no call for this, so the server invokes the menu command through Windows UI
Automation; ETABS must be visible. Walls must carry pier/spandrel labels (etabs_assign_label).

Input parameters:

- `limit` (integer): Pier/spandrel rows to return, worst first.

### `etabs_get_wall_design` (~81 tokens)

Shear wall design results: piers (reinforcing ratio, D/C, boundary zones, messages) or spandrels
(flexural and shear reinforcement), worst first. Run etabs_run_shear_wall_design first.

Input parameters:

- `kind` (string)
- `label`
- `limit` (integer)
- `story`

### `etabs_get_concrete_design` (~104 tokens)

Concrete frame design results (after etabs_run_design(kind='concrete')): required longitudinal and shear
reinforcement for beams, PMM ratios and areas for columns, joint shear and beam/column capacity ratios.
Areas are in present units.

Input parameters:

- `element` (string)
- `envelope` (boolean): One row per frame (governing station) instead of every station.
- `limit` (integer)
- `names`: Only these frames.

### `etabs_get_slab_design` (~64 tokens)

Concrete slab design results (after etabs_run_design(kind='concrete_slab')): design-strip flexure and
shear reinforcement, or punching shear checks at columns, worst first.

Input parameters:

- `limit` (integer)
- `part` (string)

### `etabs_menu` (~142 tokens)

Use ETABS menu commands that have no API, exactly as a person would click them (through Windows UI
Automation, no mouse). 'list' browses the menus; 'invoke' runs a command. Commands that open a dialog
leave it open: check with etabs_screenshot and close it with etabs_dialogs.

Input parameters:

- `action` (string)
- `confirm` (boolean): Required for 'invoke': menu commands can change or delete model data. Ask the user first.
- `path`: Menu path, e.g. ['Design', 'Shear Wall Design'] to list, or ['Analyze', 'Check Model...'] to invoke.

### `etabs_dialogs` (~67 tokens)

List or close dialogs ETABS has open. A modal dialog blocks the ETABS API, so close leftovers after
etabs_menu or a design run.

Input parameters:

- `action` (string)
- `title`: Close the dialog with this title ('close' with no title closes all).

### `etabs_code_checks` (~257 tokens)

Run the standard post-analysis checks in one call: story drift against the allowable, torsional
irregularity, soft story, weight (mass) irregularity, modal mass participation and response-spectrum base
shear vs ELF. Each check reports its clause, the governing numbers and pass/fail.

Input parameters:

- `cases`: Lateral cases/combos to check (default: every Quake, Wind and RS case).
- `checks`: Default: all.
- `drift_amplification` (number): Cd/Ie applied to elastic drifts (1.0 for wind or drifts already amplified).
- `drift_limit` (number): Allowable story drift ratio Δa/h (ASCE 7-16 Table 12.12-1: 0.020 for most Risk Category I/II buildings).
- `elf_case`
- `modal_case` (string)
- `modal_target` (number)
- `rs_case`
- `rs_direction` (string)
- `rs_target` (number)
- `soft_story_limits` (array): [ratio to story above, ratio to average of 3 above].
- `torsion_limits` (array)
- `weight_limit` (number)

### `etabs_scale_response_spectrum` (~142 tokens)

Scale a response-spectrum case so its base shear reaches the ELF base shear (ASCE 7-16 12.9.1.4),
then optionally re-run and verify.

Input parameters:

- `confirm` (boolean): Scaling unlocks the model and deletes results. Ask the user first.
- `direction` (string)
- `elf_case` (string, required)
- `rerun` (boolean): Re-run the analysis after scaling (the model is unlocked to edit the case).
- `rs_case` (string, required)
- `target` (number): Fraction of the ELF base shear to reach (ASCE 7-16: 1.0).

### `etabs_list_tables` (~89 tokens)

List ETABS database tables (definitions, assignments, analysis and design results), with whether each
has data and whether it can be edited. Result tables appear after analysis/design.

Input parameters:

- `contains`: Case-insensitive filter on the table key, e.g. 'drift', 'frame assign', 'material'.
- `include_empty` (boolean): Include tables with no data in the current model.

### `etabs_get_table` (~173 tokens)

Read any ETABS database table as rows (Display > Show Tables). Values with units are in present units.

Input parameters:

- `fields`: Only these field keys (default: all).
- `group` (string): Only objects in this group ('' = all).
- `limit`
- `load_cases`: Result tables: load cases to show. Omit both lists for all cases and combinations.
- `load_combinations`
- `numeric` (boolean): Convert fields that carry units to numbers.
- `offset` (integer)
- `table_key` (string, required): Exact table key from etabs_list_tables, e.g. 'Story Drifts' or 'Frame Assignments - Section Properties'.
- `where`: Keep rows whose fields equal these values, e.g. {'Story': 'Story3'}.

### `etabs_edit_table` (~153 tokens)

Edit a model table the way the Interactive Database editor does: read it, change/append/delete rows,
then apply. Returns ETABS's import log with error and warning counts.

Input parameters:

- `append_rows`: New rows (field key -> value); missing fields are left blank.
- `apply` (boolean): Apply the edits to the model. False validates and cancels (dry run).
- `delete_where`: Remove rows matching any of these field filters.
- `group` (string)
- `replace_rows`: Replace the entire table with these rows.
- `table_key` (string, required): An editable table key (etabs_list_tables shows editable=true).
- `updates`: Change fields on rows matching 'match'.

### `etabs_screenshot` (~141 tokens)

Take a screenshot of the ETABS window: the model views, selection and any open dialog, exactly what an
engineer sees. Use it to check geometry, deformed shapes or design colours after other tools ran.

Input parameters:

- `capture` (string): screen = what is on the monitor (brings ETABS forward for a moment, then restores focus); offscreen = never changes focus, but ETABS's GPU model views come out blank.
- `max_width` (integer)
- `refresh` (boolean): Refresh the model views first so recent API edits are drawn.
- `zoom_to_fit` (boolean): Zoom all views to the full model.

### `etabs_show_window` (~35 tokens)

Show or hide the ETABS application window. Hidden ETABS runs faster for batch work.

Input parameters:

- `visible` (boolean)

### `etabs_refresh_view` (~41 tokens)

Redraw the ETABS model views (and optionally zoom to fit) after model changes made through the API.

Input parameters:

- `zoom_to_fit` (boolean)

### `etabs_render_view` (~230 tokens)

Render the model offscreen from its data: any angle, deformed shape of any case, members coloured by
design ratio, displacement, section or storey. Works with ETABS hidden and never takes focus. Use it to
look at what you built and at results the ETABS window cannot be switched to through the API.

Input parameters:

- `azimuth`: Override the camera azimuth in degrees.
- `color_by` (string): design_ratio needs a design run; displacement needs deformed_case.
- `deformed_case`: Load case or combination whose deflected shape to draw.
- `deformed_scale`: Displacement multiplier; omit for automatic (largest deflection ≈ 4% of the model height).
- `elevation`: Override the camera elevation in degrees.
- `height` (integer)
- `highlight`: Frame names to emphasise (e.g. from etabs_find_objects).
- `show_slabs` (boolean)
- `stories`: Only draw these stories.
- `theme` (string)
- `view` (string)
- `width` (integer)

### `etabs_find_objects` (~196 tokens)

Find objects by engineering criteria: 'columns on Story3', 'beams longer than 8 m', 'members with
D/C over 0.9', 'everything in this box'. Returns names usable by every other tool; can select them.

Input parameters:

- `box`: Only objects whose centroid lies inside this box.
- `group`: Only objects assigned to this group.
- `kind` (string)
- `limit` (integer)
- `max_length`
- `max_ratio`
- `min_length`: Frames at least this long (number in present units or e.g. '8 m').
- `min_ratio`: Frames whose design D/C ≥ this (needs design results).
- `role`: Frames only, from geometry.
- `sections`: Frame sections or area properties.
- `select` (boolean): Also select the matches in ETABS (clears the current selection).
- `stories`

### `etabs_what_changed` (~103 tokens)

What changed in the model since the last call (or since the baseline): objects added, removed or
modified, sections/loads/combos/groups/stories added or removed, units, lock and file. Picks up edits
the engineer made by hand in the ETABS window, so the agent can stay in sync. The first call records
the baseline.

Input parameters:

- `limit` (integer)
- `reset` (boolean): Only record a new baseline.

### `etabs_checkpoint` (~59 tokens)

Save the model and keep a copy as a named checkpoint (an undo point before risky edits). Restore it
with etabs_restore_checkpoint. Needs a saved model.

Input parameters:

- `label` (string, required): Short name, e.g. 'before-resize'.

### `etabs_list_checkpoints` (~22 tokens)

Checkpoints saved for the open model, newest first.

### `etabs_restore_checkpoint` (~64 tokens)

Roll the model back to a checkpoint. The model keeps its original file name.

Input parameters:

- `checkpoint` (string, required): Checkpoint file name or label from etabs_list_checkpoints.
- `confirm` (boolean): Restoring replaces the current model state. Ask the user first.

### `etabs_export_model` (~136 tokens)

Export the whole model as ETABS's .e2k text and return it (paged). One read gives the complete
definition (stories, grids, materials, sections, objects, assignments, loads, cases), ideal for audits.

Input parameters:

- `max_chars` (integer)
- `offset` (integer): Character offset into the file, for paging.
- `path`: Where to write the .e2k text file (default: next to the model).
- `sections`: Only return these $-sections (prefix match), e.g. ['STORIES', 'FRAME ASSIGNS', 'LOAD PATTERNS'].

### `etabs_design_report` (~84 tokens)

Write an engineering summary in Markdown: model, loads, analysis status, base reactions, modal
periods, drifts and the design check with the most critical members. Returns the text and the file.

Input parameters:

- `path`: Write the Markdown here (default: <model>_report.md next to the model).
- `top` (integer): Critical members to list.

### `etabs_assign_label` (~116 tokens)

Assign objects to a group, pier or spandrel label (created if missing), like Assign > ... in ETABS.

Input parameters:

- `group`: Assign to every object already in this group.
- `label` (string, required)
- `label_type` (string, required): Groups organise selection and output; piers/spandrels drive wall design and forces.
- `names`
- `object_kind` (string)
- `remove` (boolean): Groups only: remove the objects from the group instead.
- `selected` (boolean)

### `etabs_search_api` (~109 tokens)

Search all ~1,300 ETABS API methods. Use this to find a method when no curated tool covers the task,
then etabs_describe_api for its parameters and etabs_call_api to run it.

Input parameters:

- `interface`: Restrict to one interface, e.g. 'cFrameObj'.
- `limit` (integer)
- `query` (string, required): Words to match against method names, interface paths and parameter names, e.g. 'frame release' or 'story drift'.

### `etabs_describe_api` (~96 tokens)

Show a method's exact signature (types, ByRef outputs, defaults, enum values, safety level), or list an
interface's methods and sub-interfaces, or an enum's values. Reflects the connected ETABS version.

Input parameters:

- `path` (string, required): A method path ('FrameObj.GetReleases'), an interface ('cFrameObj' or 'FrameObj') or an enum name ('eLoadPatternType').

### `etabs_call_api` (~146 tokens)

Call any ETABS API method. Arguments are validated and converted against the live signature; ByRef
values come back in 'outputs'. A non-zero 'ret' means ETABS rejected the call (ok=false).

Input parameters:

- `args`: Arguments by parameter name. Omit ByRef outputs; enums accept names or numbers; arrays are JSON lists.
- `confirm` (boolean): Required for destructive methods (Delete*, New*, OpenFile, unlocking...). Ask the user first.
- `max_items`: Cap on returned array lengths.
- `path` (string, required): Method path relative to SapModel ('PointObj.SetRestraint'), or 'App.<method>' for the application object.

### `etabs_call_api_batch` (~86 tokens)

Run several API calls in order in one round trip (for example, define and assign many properties).
Each result is reported; with stop_on_error the batch halts at the first failure.

Input parameters:

- `calls` (array, required)
- `confirm` (boolean): Confirms every destructive call in the batch.
- `stop_on_error` (boolean): Stop at the first failed call.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp#diagnostics

## Score history

- 2026-11-05: 60
- 2026-11-04: 80
- 2026-11-03: 80
- 2026-11-02: 80
- 2026-11-01: 80
- 2026-10-31: 80
- 2026-10-30: 80
- 2026-10-29: 80
- 2026-10-28: 65
- 2026-10-27: 65
- 2026-10-26: 65
- 2026-10-25: 65
- 2026-10-24: 65
- 2026-10-23: 65
- 2026-10-22: 65
- 2026-10-21: 65
- 2026-10-20: 65
- 2026-10-19: 65
- 2026-10-18: 65

## Common questions

### What is the ETABS MCP server?

ETABS MCP is listed in the public MCP registry as io.github.Moha2005269/etabs-mcp. Agentic MCP server for CSI ETABS v22+: model, load, analyse, design and inspect structures. This page covers its PyPI package (etabs-mcp).

### Is the ETABS MCP server safe to use?

ETABS MCP scores 60 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the ETABS MCP server expose?

ETABS MCP exposes 71 tools: etabs_list_installations, etabs_connect, etabs_instances, etabs_status, etabs_disconnect, and 66 more. Their descriptions and schemas cost roughly 7,484 tokens of context every time the server is loaded.

### Is the ETABS MCP server still maintained?

ETABS MCP is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the ETABS MCP server under?

ETABS MCP declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/etabs-mcp/
- Socket report: https://socket.dev/pypi/package/etabs-mcp
- Changelog RSS feed: https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp.json
- HTML version of this page: https://verifymcp.io/servers/moha2005269-etabs-mcp/etabs-mcp