List running Archicad instances: port, version, open project, Tapir add-on availability. Call this first.

Aggregate element counts. by_type is always returned (cheap and safe). Set include_layer_story=true to also break down by layer and story, which reads a property across every element and is refused on very large models (can crash Archicad). Counts only, never element data. 'coverage' says what element_count spans: 'whole-plan' with the Tapir add-on, 'model-elements-only' without it (then it is NOT a project total).

List loaded QA rules (id, type, severity, tags) and any rule-file load errors.

Run one QA rule by id. Returns a verdict: pass/fail, failure count, failing element GUIDs.

Run all loaded QA rules (optionally only those tagged with 'ruleset') against the open model. Returns a scored verdict.

Run only the IFC-related QA rules to check IFC export readiness. Requires the Tapir add-on for IFC data.

Highlight the elements failing a rule in the Archicad window and zoom to them (zoom=false to leave the view). Highlights every story at once. A rule with no failures removes the highlight. show_elements opens the right story or view and selects; show_elements with guids=[] removes the highlight. Requires the Tapir add-on.

Save the open project to its own file, as File > Save (Tapir). CONFIRM-GATED: without confirm=true it only reports what it would save. Call it before the reads that can crash Archicad 29 and lose unsaved work: property reads in get_element_data, set_element_data, find_elements with property comparisons, audit_delivery_readiness, run_rule, verify_ifc_export_readiness, get_model_summary with include_layer_story, modify_elements, and moving or deleting a locked element. A project never saved, or made in an older Archicad, needs File > Save As in Archicad; this tool does no Save As and says why a save was refused. On Teamwork it saves your local copy and never sends. file_updated says whether the file on disk changed.

Create an Archicad issue from a rule's failures and attach the failing elements (requires Tapir add-on).

Find elements matching criteria groups. Groups combine with OR; inside a group the comparisons combine with logical_operator 'and' (default) or 'or'. Each group may restrict element types (is / is_not) and lists comparisons of {property, operator, value}; the schema enumerates the element types and the 22 operators, and each field documents its values and units. Call search_definitions to find a property's exact address. An element with no usable value matches no binary operator. Returns GUIDs, counts, how many elements had properties read, and 'coverage' ('whole-plan' with Tapir, 'model-elements-only' without: then 2D elements are invisible and 0 is not proof of absence). Property comparisons read values in the server (no API filters by property); a read spanning more than the element ceiling is refused, so narrow with element_types, story or classification first.

Fuzzy search over property and attribute definitions, so a caller does not need to know the exact 'Group/Name'. Matches names, groups and enum values; case- and accent-insensitive. kind: 'property', 'attribute' (layers, fills, surfaces, composites, profiles, pen tables, ...) or 'any'. alternatives: up to 6 synonyms or translations searched too (useful on non-English projects). editable_only: keep only properties whose value can be written on at least one element type; check it before set_element_data. Each property match carries 'property', the exact address find_elements, get_element_data, set_element_data and rules accept, plus value_type, measure_type (Length/Area/Volume/Angle values are in m, m2, m3, radian), collection, editable, expression_based and enum_values. Results are ranked: whole-word matches first, then word starts, then substrings; a query word under 4 letters must start a word. total_matches counts everything; pass next_offset as offset to page past limit. Reads definitions only, never property values.

Read type, layer and requested values of the given elements. properties takes addresses: a property ('Group/Name', a built-in name or a property GUID, as search_definitions gives it); 'classification:' (the item ID); 'gdl:' (a GDL parameter of an object, lamp, door, window or other library part element); 'marker:' (a door's or window's marker parameter, Tapir 1.7.1); 'ifc:.' (an IFC property). Lengths in metres, angles in radians, attribute-typed GDL parameters as attribute indexes. 'gdl:', 'marker:', 'ifc:' and 'classification:' read every value, with display names in 'labels'; at most 20 elements per wildcard call. A kind that cannot be read for an element is named in its 'unreadable'. include_classifications adds every system's item GUID.

Write element data. DRY-RUN BY DEFAULT: returns planned changes (current -> new) without touching the model; pass dry_run=false to commit. A change is {guid, property, value}; property takes the addresses get_element_data reads (a property, 'classification:', 'gdl:', 'marker:', 'ifc:.'), so one call can mix kinds. Classification values are an item ID or GUID, null unclassifies. GDL and marker values in metres and radians, an array as the whole list in its own shape (rows for two dimensions; array writes need Tapir 1.7.2), an attribute parameter by index or name. IFC values are text, a number or true/false, with an optional ifc_type (IfcLabel for text by default); Tapir writes IFC properties only in Archicad 27 and older. A commit sends classifications first and reads every change back: 'applied' counts what reads as sent; 'not_applied', changes Archicad answered success for but kept or replaced (a GDL Parameter Script can); 'failed', Archicad's refusals grouped by code and message with a count and sample GUIDs; 'skipped', changes not sent, with the reason (value type, enum, unknown parameter, or an element Archicad would refuse: in another view's database than the active window's, on a hidden or locked layer, inside a hotlinked module, locked with Edit > Locking, or not reserved in Teamwork); 'not_sent' and 'stopped' if a batch was refused outright after earlier batches landed; 'unconfirmed' if the read after the write failed.

Edit custom property DEFINITIONS in place (not element values): name, description, group, default value or expressions, availability, enum options. DRY-RUN BY DEFAULT: returns each property's before/after and warnings; pass dry_run=false to commit. Address properties as 'Group/Name' (search_definitions) or GUID; availability entries as 'System/Code', with '/' for the item and everything below it; enum options by their text (or GUID when two options share a text). Example change: {"property": "Office/Status", "name": "Approval", "availability": {"add": ["Uniclass/Ss_25/"]}, "enum": {"rename": {"Old": "New"}, "remove": ["X"], "add": ["Y"], "order": [...]}, "default": "New"}. GUIDs are kept, so element values survive everything except removing an option (those elements show ) or availability. In a Teamwork project the Properties set must be reserved first (reserve_elements object_sets). Needs the Tapir build with UpdateClassificationItems.

Edit classification systems and items in place. DRY-RUN BY DEFAULT; pass dry_run=false to commit. Items: {"item": "System/Code", "code"?, "name"?, "description"?}. Systems: {"system": "Name", "name"?, "description"?, "source"?, "version"?, "date"? (YYYY-MM-DD)}. Items keep their GUID, so classified elements and property availability stay attached. Moving an item to another parent is not supported. In a Teamwork project the Classifications set must be reserved first (reserve_elements object_sets).

Import a Property Manager (kind='property') or Classification Manager (kind='classification') XML file. DRY-RUN BY DEFAULT: lists what is new and what collides with existing names, and what the conflict policy does. conflict: property append|replace|skip; classification merge|replace|skip (item_conflict replace|skip). Commit returns what was created and removed.

Create elements of any type Tapir can create. element_type: model wall, beam, column, slab, roof, morph, mesh, stair, railing, zone, curtain_wall, grid_element, object, lamp; hosted door, window (in a wall), opening; MEP mep_route, mep_element (Archicad 28+), electrical_panel, electrical_device, electrical_circuit (Archicad 30); markers section, interior_elevation; hotlink_instance; 2D line, arc, circle, polyline, spline, hatch, hotspot, text, label, keynote_label; dimension, level_dimension, wall_thickness_dimension, section_dimension; drawing (on a layout). Plurals and Tapir command names work too. Items use Tapir's field names and units (metres, radians): call with items=[] to get the item schema for a type. DRY-RUN BY DEFAULT: every item is validated against the schema (any problem: nothing is sent, problems listed by item index and field), a favoriteName and a libraryPartName must exist (closest names suggested), and hosts (a door's wall, the elements a dimension measures, a label's parent) must exist, be the right type and be editable; items failing those are skipped with the reason and the rest go ahead. Warns when the active window is wrong for the type, when an object or lamp has no dimensions (it would take the tool's current size, not the library part's) and when it sends offset or useFixedAngle (Archicad discards them). Pass dry_run=false to create: returns created GUIDs, plus Tapir's per-item errors grouped with item indices and by_index (item index -> GUID) when not every item was created.

Place a Swept Beam: a sloped, curved beam with a Profile Manager profile or a rectangle, as the 'Swept Beam' library part. The path comes from source_guid (a Morph line, Polyline, Line or Arc) or from points [{x, y, z}] in metres. Flat sources take start_height (metres above the source) and slope_percent; morph lines and points keep their own heights. profile is {"attribute": ""} or {"rectangle": {"width", "height", "building_material"}} (default 0.2 x 0.2 rectangle). update_guid rewrites the path of an existing Swept Beam, keeping its GUID; its profile, offsets, flip and end cuts stay unless given, and node roll resets to 0. End cuts in degrees: cut_start_plan and cut_end_plan turn a cut counter-clockwise from square in plan (-80 to 80); cut_start_tilt and cut_end_tilt lean the top of the face out past the end (-85 to 85, 0 is square to the beam, the beam's slope there gives a vertical face). ref_line ('left face', 'centre', 'right face', looking from the first point to the last) puts that face of the beam on the path; ref_offset (metres) moves the beam that far away from it (with centre, to the right). DRY-RUN BY DEFAULT: reports nodes, arcs, the maximum deviation from the source and warnings. Pass dry_run=false to place or update.

Place a Road Marking (lane lines, zebra crossings, stop and give way lines, parking rows, disabled, taxi and EV bays, bus and taxi stops, BUS and TAXI lettering) as the 'Road Marking' library part, and drape it onto Meshes and Slabs. The path comes from source_guid (a Morph line, Polyline, Line or Arc) or points [{x, y, z}] in metres. marking is a preset name, for example '5121 Broken divider, in settlements', '5352-1 Disabled bays, shared zone' or '5333-2 Bus stop on the carriageway', or 'Custom'. stripes changes stripes: {"1": {on, offset, width, dash, gap, angle, shape}}; bays sets {layout, width, depth, zone_width, zone_first, bar_width, symbol}; lettering sets {text, length, width, gap, offset, align, shift, repeat}. Offsets, bays and the word lie to the right looking from the first point to the last. drape_on lists Mesh and Slab GUIDs: the cross fall follows the surface, the paint never sinks below it, and nodes are added until the marking is within drape_tolerance (metres) of it along the path; lift raises it. update_guid rewrites a placed marking, keeping its settings unless given; with drape_on and no source it drapes the marking's own path. DRY-RUN BY DEFAULT: reports nodes, the marking's reach, drape deviations, stretches off the surface and warnings. Pass dry_run=false to place or update.

Move elements by a vector {x,y,z} in meters. Refuses without confirm=true. Archicad changes only elements in the database of the active window, so elements it would refuse (another view's, on a hidden or locked layer, not reserved in Teamwork, inside a hotlinked module, locked, or not found) are not sent. Returns requested; moved, counted from Archicad's per-element results; not_moved grouped by reason with the GUIDs; and active_window when anything was refused up front.

Change existing elements. DRY-RUN BY DEFAULT: returns per element the current and new value of every field, plus skipped elements with the reason and warnings; pass dry_run=false to commit. Each change is {"guid", ...fields}. Any element: story (index, ground floor 0, or a story name; the element keeps its height above the story and moves with it unless keep_elevation=true), layer (name), draw_order (1 to 14, 0 = the type's default). Walls, beams, slabs, columns, windows, doors, morphs, multi-plane roofs, meshes, objects, lamps, texts and labels also take the fields of Tapir's Modify command by its own names (describe_api_command ModifyWalls lists them), e.g. height, thickness, sillHeight, lightIsOn. Attribute fields (buildingMaterialId, compositeId, profileId, surfaceId, lineTypeId, sectionFillId, ...) take a name. Lengths in metres, angles in radians, text sizes in mm. Partial coordinates, dimensions and visibility are completed from the current values. Elements Archicad would refuse (another view's, hidden or locked layer, not reserved in Teamwork, inside a hotlinked module, locked) are skipped with the reason, never unlocked. A commit reads the elements back: 'modified' counts what landed, 'failed' groups Archicad's refusals, 'not_applied' lists fields Archicad answered success for but did not change.

Make existing elements match a favourite (Tapir), the office standard in one step. Without favorite it changes nothing and lists the favourites that fit the given elements' types (all types when no guids either). DRY-RUN BY DEFAULT: lists the elements it would change, skips with the reason those of another type than the favourite's or that Archicad would refuse (another view's, hidden or locked layer, not reserved in Teamwork, inside a hotlinked module, locked), and warns what the favourite takes over besides materials and pens: a wall's height, top link, reference line and structure, a column's height and top link, a door's or window's library part, size and sill, and every element's layer; for other types it says what was not checked live. Plan positions stay. Stairs, railings and curtain walls get only their own settings, not their parts'. keep (default ["id"]) writes each element's own Element ID back after the favourite, and "layer" its own layer; use modify_elements for heights and sizes. settings, classifications, categories and properties choose what the favourite applies; classifications are added per system and property values overwrite. Pass dry_run=false to apply: returns applied, changed (per element current and new of every field the favourite changed, read back), unchanged, failed grouped by reason, and restored for keep. Classifications, categories and properties are not read back. to_defaults=true with no guids sets the favourite's tool defaults instead.

Delete elements. IRREVERSIBLE. Refuses without confirm=true. Archicad deletes only elements in the database of the active window and still answers success for the rest (a floor-plan label cannot be deleted while a Layout is active), so elements it would refuse (another view's, on a hidden or locked layer, not reserved in Teamwork, inside a hotlinked module, locked, or not found) are not sent, and the rest are read back afterwards. Returns requested; deleted, the count that is really gone; not_deleted grouped by reason with the GUIDs; active_window when anything was refused up front; and stopped if the delete command itself errored.

Return the GUIDs of the elements currently selected in Archicad, and 'coverage': 'whole-plan' when read through the Tapir add-on, 'model-elements-only' without it (then selected markers, 2D elements and native MEP routes are left out, and an empty list is not proof that nothing is selected).

Replace the current selection with the given element GUIDs. Whatever the user had selected by hand is deselected. The selection is read back afterwards. Returns requested; selected, the count Archicad really selected (it answers success and still leaves some unselected: section Objects, railing sub-elements, elevation marker parts, or GUIDs not in the plan); not_selected with those GUIDs when any; and the coverage of the read, as get_selection.

Deselect everything in the Archicad window.

Show elements to the user in Archicad: open the story or view that holds them (a section, elevation, detail, worksheet or layout when they are not on the floor plan), select them, highlight them and zoom to them. When they span several stories or views, the one holding the most is shown and the rest are listed (on_other_stories, in_other_views) for another call; with the 3D window in front, floor plan elements are shown there across every story. selected counts what Archicad really selected (not_selectable lists the rest). highlight=false removes any earlier highlight; guids=[] removes the highlight and, with select, the selection, and changes nothing else. Changes only what is on screen, never the project.

See what the current Archicad window shows (floor plan, section, 3D, layout ...) as an image, to check a result by eye: which way a placed object faces, which way a door opens, whether walls meet. Call show_elements first to bring the elements into view. entire_drawing=true covers the whole drawing of a 2D window instead of the current zoom. Images larger than 1568 pixels are scaled down (scaled_from gives the original size). Needs Tapir 1.7.2. Reads only.

Find clashes: which elements of one group collide with which elements of another (Tapir). The first group is guids plus every element of element_types; the second is against_guids plus against_types, and without it the first group is checked against itself. Element types are Archicad's names (Wall, Beam, Column, Slab, Object, Morph, ...); for property criteria call find_elements first and pass its GUIDs. volume_tolerance (m3, default 0.001) is the overlap volume below which a clash is ignored; surface_tolerance (m2) also reports touching faces over that area. Returns each pair with both elements' type and ID, the first one's story, and kind (body, clearance for MEP clearance zones, or both), counts by type pair, and 'elements', every GUID in a pair, to pass to show_elements. Archicad does not count elements its own junctions clean up (crossing walls); the volume check sees only closed bodies, so an open surface (a Morph surface) clashes only with surface_tolerance set; building materials set not to take part in collision detection are left out. No pairs is not proof that nothing overlaps. A whole-model check can take a while. Reads only.

Reserve elements, and non-element object sets, in a Teamwork project so you can edit them (Tapir). CONFIRM-GATED: without confirm=true it only reports what it can learn without touching the server: not_found, already_mine, and would_attempt. Whether another user holds an element is only learned by attempting, because Archicad exposes no read for it. With confirm=true returns reserved, reserved_by_others (with the user's name), already_mine, not_found, and indirectly_reserved: elements Archicad pulled into your workspace that you did not ask for, such as a door's wall. object_sets reserves what attribute, property and classification edits need: an attribute type (Layers, Composites, Fills, Lines, PenTables, Profiles, BuildingMaterials, Surfaces, ZoneCategories), Properties or Classifications, or any Archicad set name (Favorites, ProjectInfo, ...); needs Tapir 1.7.1. Each set's entry says status, held_by and outcome (would_reserve, already_mine, held_by_others, reserved, failed); for sets the dry run does know who holds them. A reservation is visible to every teammate and blocks their edits until released.

Release elements, and non-element object sets, from your Teamwork workspace (Tapir). CONFIRM-GATED: without confirm=true it reports would_release (the ones actually in your workspace), not_mine and not_found. With confirm=true releases them and reports released and still_mine. Unsent changes on a released element are not lost by this call; TeamworkSend is the gateway's job. object_sets takes the names reserve_elements takes; releasing a set sends that set's changes to the server first (Archicad does that as part of the release).

Project info: Archicad version, project name, stories, hotlinks, geolocation presence (Tapir enriches).

List attributes by type: Layer, LayerCombination, Line, Fill, ZoneCategory, PenTable, Profile, BuildingMaterial, Composite, Surface (plurals work). Names only by default. details=true returns each attribute's settings (Tapir): a composite's skins and separators, a building material's fills and physical values, a layer combination's layer states, a pen table's pens, ... with references to other attributes shown by name, in the vocabulary edit_attributes takes. names= picks attributes; otherwise details are paged (limit, offset; next_offset when more remain).

Create, modify and delete attributes (layers, layer combinations, lines, fills, zone categories, pen tables, profiles, building materials, composites, surfaces) and set attribute property values (Tapir). DRY-RUN BY DEFAULT; pass dry_run=false to commit. Each change has one action key whose value is the type: {"create": "Layer", "name": "X", } makes a new one and NEVER overwrites (an existing name is skipped, with what would change and the modify to send instead); {"modify": "Composite", "attribute": "", } changes an existing one (name renames; fields not given keep their value, including what Tapir's own overwrite would drop: a composite's useWith, a building material's texts); {"modify": ..., "properties": {"Group/Name": "value"}} sets property values; {"delete": "Fill", "attribute": ...} deletes. Fields use Tapir's names and units (metres, radians, pen numbers); a field holding another attribute (buildingMaterialId, lineTypeId, fillId, cutFillIndex, a layer combination's layers[].attributeId) takes its name. changes=[] lists every type's fields; list_attributes(details=true) shows current values in the same form. The dry run shows current -> new and skips with the reason anything Archicad or Tapir would refuse or silently get wrong: misspelt enums, unknown references, Archicad's own index 1 attributes, a layer delete while elements are on the layer (it would delete them) or without the floor plan active. In Teamwork the attribute type's set must be reserved (reserve_elements object_sets). Attribute writes cannot be undone. A commit returns applied (read back), not_applied, failed (grouped) and stopped.

List the issues in the open project, with their ids (requires the Tapir add-on).

Create a new issue in the open project and return its id (requires the Tapir add-on).

Add a text comment to an existing issue, addressed by its id (requires the Tapir add-on).

Attach elements to an existing issue as highlights (requires the Tapir add-on).

Export every issue in the project to a BCF file at the given path, aligned to the survey point. Overwrites the file if it exists (requires the Tapir add-on).

Import issues into the project from a BCF file, aligned to the survey point (requires the Tapir add-on).

Save the project as an IFC file, the step after verify_ifc_export_readiness. DRY-RUN BY DEFAULT: returns the translator, path, file type and scope, and lists every translator; pass dry_run=false to write. path: absolute, ending in .ifc or .ifczip. translator: a name from the project's IFC translators (default: the preview translator). scope: EntireProject, VisibleElementsOnAllStories (default), AllElementsOnCurrentStory, VisibleElementsOnCurrentStory or SelectedElementsOnly. Refuses to replace an existing file unless overwrite=true. Archicad exports from the floor plan or the 3D window, so from any other window it first brings the floor plan to the front and leaves it there. The commit checks the file and returns its size. Never opens or merges IFC. Needs Tapir 1.6.0.

Fire an Archicad publisher set by name (Tapir).

Install the pinned Tapir add-on (1.7.2) into Archicad's Add-Ons folder. Dry run by default: it finds every Archicad on this computer, downloads and checks the file (sha256) and says what it would do. confirm=true writes. Never replaces an existing Tapir unless replace_existing=true, and then moves the old copy to a backup folder; a custom Tapir build loses its own commands when replaced. archicad_version limits it to one version. On macOS a protected Add-Ons folder brings up the system password dialog; on Windows it returns the command to run from an administrator terminal. Archicad must be restarted afterwards. Needs no running Archicad.

Describe an exported Archicad schedule scheme XML: its criteria and its ordered columns, with what each column binds to. Schedules have no API, so export the scheme first via Document > Schedules > Scheme Settings > Export and pass the file path. Reads the file only, never Archicad.

Apply a YAML scheme spec to an exported schedule scheme XML: set the columns and their order, retarget bindings, rename the scheme. DRY-RUN BY DEFAULT: returns the before and after column lists and writes nothing until dry_run=false. Never overwrites the input; writes to 'output' or to .edited.xml beside it. Import the result via Document > Schedules > Scheme Settings > Import. Criteria are preserved, not yet editable. A spec that binds every property by GUID needs no Archicad connection and runs fully offline; a spec that binds a property by a 'Group/Name' string needs Archicad open so the name can be resolved.

Check an exported schedule scheme against the open project: do its property bindings still exist, and does any column caption disagree with what it is bound to. Reads property definitions only, not values, so it does not risk the property-read crash.

Catalog of ALL available Archicad API commands (official JSON API + Tapir). Filter by group, or by access='read' / 'write' to see which of the two execute tools runs a given command.

Full description and input schema for one API command. Call before execute_read_api_command or execute_write_api_command.

Run one read-only Archicad API command by name and return its result. Covers the official Archicad JSON API (https://archicadapi.graphisoft.com/JSONInterfaceDocumentation/) and the Tapir add-on (https://github.com/ENZYME-APD/tapir-archicad-automation). Reads only: a command that changes the project is refused here and belongs to execute_write_api_command. Params are validated against the bundled schema where available. Prefer the dedicated tools when one exists.

Run one Archicad API command that changes the project. Covers the official Archicad JSON API (https://archicadapi.graphisoft.com/JSONInterfaceDocumentation/) and the Tapir add-on (https://github.com/ENZYME-APD/tapir-archicad-automation). IRREVERSIBLE for many commands, and reaches DeleteElements and QuitArchicad among others. Refuses without confirm=true; the refusal echoes the command and params it would have run. Params are validated against the bundled schema where available. Prefer the dedicated tools when one exists.