Find all running Archicad instances.

Scans ports 19723-19744 for Archicad's JSON API. Returns instance info including port, project name, version. Use the 'port' value in other tools to target a specific instance.

Get documentation for Archicad commands.

USAGE: get_docs() # Overview: categories with counts get_docs(category="Element Commands") # Browse: commands in a category get_docs(search="...") # Find commands by keyword get_docs(command="CommandName") # Full schema for one command get_docs(commands=["A", "B"]) # Full schemas for multiple

DISCOVERY WORKFLOW:

1. get_docs() -> see categories

2. get_docs(category="...") -> see command names

3. get_docs(command="...") -> full schema

SEARCH FEATURES:

• Searches across: names, descriptions, parameters, examples, notes

• Element types: "wall" -> suggests GetElementsByType(elementType="Wall")

• Partial match: "prop" finds property commands

• Typo tolerant: "proprty" -> property commands

• Multi-word: "create slab" finds CreateSlabs

Args: search: Search query (e.g., "wall", "create slab", "property") command: Exact command name for full schema commands: List of command names for full schemas category: Category name to list all commands in it

Examples: get_docs() # Overview get_docs(category="Element Commands") # Browse category get_docs(search="wall") # Commands for walls get_docs(search="create") # Creation commands get_docs(command="CreateSlabs") # Full schema for CreateSlabs

Search and discover Archicad element properties.

Properties are attributes like area, length, volume that you query on elements. Use this to find property GUIDs needed for GetPropertyValuesOfElements.

WHEN TO USE:

• "Get wall areas" → get_properties(search="area", group="Wall")

• "What properties can I query on zones?" → get_properties(group="Zone")

• "Find custom/user-defined properties" → get_properties(property_type="Custom")

MODES: get_properties(port) # Overview of all groups get_properties(port, search="length") # Search by keyword get_properties(port, group="Wall") # All properties for element type get_properties(port, property="Length of Reference Line") # Exact lookup

Args: port: Archicad instance port (from list_instances) search: Search property names (e.g., "area", "length", "surface") group: Filter by group/element type (e.g., "Wall", "Zone", "Geometry") property_type: Filter by type: "StaticBuiltIn", "DynamicBuiltIn", "Custom" measure_type: Filter by unit: "Length", "Area", "Volume", "Angle" property: Exact property name lookup (returns single match with GUID) limit: Max results (default 50, max 200)

Returns: Properties with GUIDs ready for GetPropertyValuesOfElements.

NOTE: For command documentation (API schemas), use get_docs instead.

Execute Python script with full Archicad API access.

SCRIPT NAMESPACE

archicad object (async methods - use await): await archicad.tapir(name, params) # Tapir commands await archicad.command(name, params) # Built-in API (prefix with "API.")

TAPIR COMMANDS

ChangeWindow(windowType: "FloorPlan"|"Section"|"Details") -> {success: bool} Changes the current (active) window to the given window.

GetAddOnVersion() -> {version: str} Retrieves the version of the Tapir Additional JSON Commands Add-On.

GetArchicadLocation() -> {archicadLocation: str} Retrieves the location of the currently running Archicad executable.

GetCurrentWindowType() -> {currentWindowType: "FloorPlan"|"Section"|"Details"} Returns the type of the current (active) window.

QuitArchicad() -> {success: bool} Performs a quit operation on the currently running Archicad instance.

CreateBuildingMaterials(buildingMaterialDataArray: [{attributeId: {guid: str}, index: str, name: str, id: str, manufacturer: str, description: str, connPriority: int, cutFillIndex: int, cutFillPen: int, cutFillBackgroundPen: int, cutSurfaceIndex: int, thermalConductivity: num, density: num, heatCapacity: num, embodiedEnergy: num, embodiedCarbon: num}], overwriteExisting: bool) -> {attributeIds: [{attributeId: {guid}}]} Creates or overwrites Building Material attributes based on the given paramet...

CreateComposites(compositeDataArray: [{attributeId: {guid: str}, index: str, name: str, useWith: [str], skins: [{type, buildingMaterialId, framePen, thickness}], separators: [{lineTypeId, linePen}]}], overwriteExisting: bool) -> {attributeIds: [{attributeId: {guid}}]} Creates or overwrites Composite attributes based on the given parameters.

CreateLayerCombinations(layerCombinationDataArray: [{attributeId: {guid: str}, index: str, name: str, layers: [{attributeId, isHidden, isLocked, isWireframe, intersectionGroupNr}]}], overwriteExisting: bool) -> {attributeIds: [{attributeId: {guid}}]} Creates or overwrites Layer Combination attributes based on the given paramet...

CreateLayers(layerDataArray: [{attributeId: {guid: str}, index: str, name: str, isHidden: bool, isLocked: bool, isWireframe: bool, intersectionGroupNr: int}], overwriteExisting: bool) -> {attributeIds: [{attributeId: {guid}}]} Creates or overwrites Layer attributes based on the given parameters.

CreateSurfaces(surfaceDataArray: [{attributeId: {guid: str}, index: str, name: str, materialType: "General"|"Simple"|"Matte", ambientReflection: num, diffuseReflection: num, specularReflection: num, transparency: num, shine: num, transparencyAttenuation: num, emissionAttenuation: num, surfaceColor: {red: num, green: num, blue: num}, specularColor: {red: num, green: num, blue: num}, emissionColor: {red: num, green: num, blue: num}, fillId: {attributeId: {guid}}, texture: {name: str, rotationAngle: num, xSize: num, ySize: num, FillRectangle: bool, FitPicture: bool, mirrorX: bool, mirrorY: bool, useAlphaChannel: bool, alphaChannelChangesTransparency: bool, alphaChannelChangesSurfaceColor: bool, alphaChannelChangesAmbientColor: bool, alphaChannelChangesSpecularColor: bool, alphaChannelChangesDiffuseColor: bool}}], overwriteExisting: bool) -> {attributeIds: [{attributeId: {guid}}]} Creates or overwrites Surface attributes based on the given parameters.

GetAttributesByType(attributeType: "Layer"|"Line"|"Fill") -> {} Returns the details of every attribute of the given type.

GetBuildingMaterialPhysicalProperties(attributeIds: [{attributeId: {guid: str}}]) -> {properties: [{properties: {thermalConductivity, density, heatCapacity, embodiedEnergy, embodiedCarbon}}]} Retrieves the physical properties of the given Building Materials.

GetLayerCombinations(attributes: [{attributeId: {guid: str}}]) -> {layerCombinations: [{}]} Returns the details of layer combination attributes.

GetDesignOptionCombinations() -> {designOptionCombinations: [{designOptionCombinationId: {guid}, name: str, activeDesignOptions: [...]}]} Retrieves information about existing design option combinations.

GetDesignOptionSets() -> {designOptionSets: [{designOptionSetId: {guid}, name: str, designOptions: [...]}]} Retrieves information about existing design option sets. Available from Archi...

GetDesignOptions() -> {designOptions: [{designOptionId: {guid}, name: str, id: str, ownerSetName: str}]} Retrieves information about existing design options. Available from Archicad 29.

GenerateDocumentation(destinationFolder: str) -> {success: bool} Generates files for the documentation. Used by Tapir developers only.

ChangeSelectionOfElements(addElementsToSelection: [{elementId: {guid}}], removeElementsFromSelection: [{elementId: {guid}}]) -> {executionResultsOfAddToSelection: [{success: bool}], executionResultsOfRemoveFromSelection: [{success: bool}]} Adds/removes a number of elements to/from the current selection.

CreateColumns(columnsData: [{coordinates: {x: num, y: num, z: num}}]) -> {elements: [{elementId: {guid}}]} Creates Column elements based on the given parameters.

CreateLabels(labelsData: [{parentElementId: {guid}, text: str, begCoordinate: {x, y}, floorInd: num}]) -> {elements: [{elementId: {guid}}]} Creates Label elements based on the given parameters.

CreateMeshes(meshesData: [{floorIndex: int, level: num, skirtType: "SurfaceOnlyWithoutSkirt"|"WithSkirt"|"SolidBodyWithSkirt", skirtLevel: num, polygonCoordinates: [{x, y, z}], polygonArcs: [{begIndex, endIndex, arcAngle}], holes: [{polygonCoordinates, polygonArcs}], sublines: [{coordinates}]}]) -> {elements: [{elementId: {guid}}]} Creates Mesh elements based on the given parameters.

CreateObjects(objectsData: [{libraryPartName: str, coordinates: {x, y, z}, dimensions: {x: num, y: num, z: num}}]) -> {elements: [{elementId: {guid}}]} Creates Object elements based on the given parameters.

CreatePolylines(polylinesData: [{floorInd: num, coordinates: [{x, y}], arcs: [{begIndex, endIndex, arcAngle}]}]) -> {elements: [{elementId: {guid}}]} Creates Polyline elements based on the given parameters.

CreateSlabs(slabsData: [{level: num, polygonCoordinates: [{x, y}], polygonArcs: [{begIndex, endIndex, arcAngle}], holes: [{polygonCoordinates: [{x, y}]}]}]) -> {elements: [{elementId: {guid}}]} Creates Slab elements based on the given parameters.

CreateZones(zonesData: [{floorIndex: num, name: str, numberStr: str, categoryAttributeId: {guid: str}, stampPosition: {x, y}, geometry: {}}]) -> {elements: [{elementId: {guid}}]} Creates Zone elements based on the given parameters.

DeleteElements(elements: [{elementId: {guid}}]) -> {success: bool} Deletes elements.

FilterElements(elements: [{elementId: {guid}}], filters: ["IsEditable"|"IsVisibleByLayer"|"IsVisibleByRenovation"]) -> {elements: [{elementId: {guid}}]} Tests an elements by the given criterias.

Get3DBoundingBoxes(elements: [{elementId: {guid}}]) -> {boundingBoxes3D: [{}]} Get the 3D bounding box of elements. The bounding box is calculated from the ...

GetAllElements(filters: ["IsEditable"|"IsVisibleByLayer"|"IsVisibleByRenovation"], databases: [{databaseId: {guid: str}}]) -> {} Returns the identifier of all elements on the plan. Use the optional filter p...

GetClassificationsOfElements(elements: [{elementId: {guid}}], classificationSystemIds: [{classificationSystemId: {guid: str}}]) -> {elementClassifications: [{}]} Returns the classification of the given elements in the given classification ...

GetCollisions(elementsGroup1: [{elementId: {guid}}], elementsGroup2: [{elementId: {guid}}], settings: {volumeTolerance: num, performSurfaceCheck: bool, surfaceTolerance: num}) -> {collisions: [{elementId1: {guid}, elementId2: {guid}, hasBodyCollision: bool, hasClearenceCollision: bool}]} Detect collisions between the given two groups of elements.

GetConnectedElements(elements: [{elementId: {guid}}], connectedElementType: "Wall"|"Column"|"Beam") -> {} Gets connected elements of the given elements.

GetDetailsOfElements(elements: [{elementId: {guid}}]) -> {detailsOfElements: [{type: "Wall"|"Column"|"Beam", id: str, floorIndex: num, layerIndex: num, drawIndex: num, details: {}}]} Gets the details of the given elements (geometry parameters etc).

GetElementPreviewImage(elementId: {guid}, imageType: "2D"|"Section"|"3D", format: "png"|"jpg", width: int, height: int) -> {previewImage: str} Returns the preview image of the given element.

GetElementsByType(elementType: "Wall"|"Column"|"Beam", filters: ["IsEditable"|"IsVisibleByLayer"|"IsVisibleByRenovation"], databases: [{databaseId: {guid: str}}]) -> {} Returns the identifier of every element of the given type on the plan. It wor...

GetGDLParametersOfElements(elements: [{elementId: {guid}}]) -> {gdlParametersOfElements: [{parameters: [...]}]} Gets all the GDL parameters (name, type, value) of the given elements.

GetRoomImage(zoneId: {guid}, format: "png"|"jpg", width: int, height: int, offset: num, scale: num, backgroundColor: {red: num, green: num, blue: num}) -> {roomImage: str} Returns the room image of the given zone.

GetSelectedElements() -> {elements: [{elementId: {guid}}]} Gets the list of the currently selected elements.

GetSubelementsOfHierarchicalElements(elements: [{elementId: {guid}}]) -> {subelements: [{cWallSegments: [{elementId: {guid}}], cWallFrames: [{elementId: {guid}}], cWallPanels: [{elementId: {guid}}], cWallJunctions: [{elementId: {guid}}], cWallAccessories: [{elementId: {guid}}], stairRisers: [{elementId: {guid}}], stairTreads: [{elementId: {guid}}], stairStructures: [{elementId: {guid}}], railingNodes: [{elementId: {guid}}], railingSegments: [{elementId: {guid}}], railingPosts: [{elementId: {guid}}], railingRailEnds: [{elementId: {guid}}], railingRailConnections: [{elementId: {guid}}], railingHandrailEnds: [{elementId: {guid}}], railingHandrailConnections: [{elementId: {guid}}], railingToprailEnds: [{elementId: {guid}}], railingToprailConnections: [{elementId: {guid}}], railingRails: [{elementId: {guid}}], railingToprails: [{elementId: {guid}}], railingHandrails: [{elementId: {guid}}], railingPatterns: [{elementId: {guid}}], railingInnerPosts: [{elementId: {guid}}], railingPanels: [{elementId: {guid}}], railingBalusterSets: [{elementId: {guid}}], railingBalusters: [{elementId: {guid}}], beamSegments: [{elementId: {guid}}], columnSegments: [{elementId: {guid}}]}]} Gets the subelements of the given hierarchical elements.

GetZoneBoundaries(zoneElementId: {guid}) -> {} Gets the boundaries of the given Zone (connected elements, neighbour zones, e...

HighlightElements(elements: [{elementId: {guid}}], highlightedColors: [[int]], wireframe3D: bool, nonHighlightedColor: [int]) -> {success: bool} Highlights the elements given in the elements array. In case of empty element...

MoveElements(elementsWithMoveVectors: [{elementId: {guid}, moveVector: {x: num, y: num, z: num}, copy: bool}]) -> {executionResults: [{success: bool}]} Moves elements with a given vector.

RemoveElementNotificationClient(host: str, port: int) -> {success: bool} Removes an element notification client.

SetClassificationsOfElements(elementClassifications: [{elementId: {guid}, classificationId: {classificationSystemId, classificationItemId}}]) -> {executionResults: [{success: bool}]} Sets the classifications of elements. In order to set the classification of a...

SetDetailsOfElements(elementsWithDetails: [{elementId: {guid}, details: {floorIndex: num, layerIndex: num, drawIndex: num, typeSpecificDetails: {}}}]) -> {executionResults: [{success: bool}]} Sets the details of the given elements (floor, layer, order etc).

SetElementNotificationClient(host: str, port: int, notifyOnNewElement: bool, notifyOnModificationOfAnElement: bool, notifyOnReservationChanges: bool) -> {success: bool} Sets up a new notification client to receive element events.

SetGDLParametersOfElements(elementsWithGDLParameters: [{elementId: {guid}, gdlParameters: [...]}]) -> {executionResults: [{success: bool}]} Sets the given GDL parameters of the given elements.

ApplyFavoritesToElementDefaults(favorites: [str]) -> {executionResults: [{success: bool}]} Apply the given favorites to element defaults.

CreateFavoritesFromElements(favoritesFromElements: [{elementId: {guid}, favorite: str}]) -> {executionResults: [{success: bool}]} Create favorites from the given elements.

GetFavoritePreviewImage(favorite: str, imageType: "2D"|"Section"|"3D", format: "png"|"jpg", width: int, height: int) -> {previewImage: str} Returns the preview image of the given favorite.

GetFavoritesByType(elementType: "Wall"|"Column"|"Beam") -> {} Returns a list of the names of all favorites with the given element type

AddCommentToIssue(issueId: {guid: str}, author: str, status: "Error"|"Warning"|"Info", text: str) -> {success: bool} Adds a new comment to the specified issue.

AttachElementsToIssue(issueId: {guid: str}, elements: [{elementId: {guid}}], type: "Creation"|"Highlight"|"Deletion") -> {success: bool} Attaches elements to the specified issue.

CreateIssue(name: str, parentIssueId: {guid: str}, tagText: str) -> {issueId: {guid: str}} Creates a new issue.

DeleteIssue(issueId: {guid: str}, acceptAllElements: bool) -> {success: bool} Deletes the specified issue.

DetachElementsFromIssue(issueId: {guid: str}, elements: [{elementId: {guid}}]) -> {success: bool} Detaches elements from the specified issue.

ExportIssuesToBCF(issues: [{issueId: {guid: str}}], exportPath: str, useExternalId: bool, alignBySurveyPoint: bool) -> {success: bool} Exports specified issues to a BCF file.

GetCommentsFromIssue(issueId: {guid: str}) -> {comments: [{guid: str, author: str, text: str, status: "Error"|"Warning"|"Info", creaTime: int}]} Retrieves comments information from the specified issue.

GetElementsAttachedToIssue(issueId: {guid: str}, type: "Creation"|"Highlight"|"Deletion") -> {elements: [{elementId: {guid}}]} Retrieves attached elements of the specified issue, filtered by attachment type.

GetIssues() -> {issues: [{issueId: {guid}, name: str, parentIssueId: {guid}, creaTime: int, modiTime: int, tagText: str, tagTextElementId: {guid}, isTagTextElemVisible: bool}]} Retrieves information about existing issues.

ImportIssuesFromBCF(importPath: str, alignBySurveyPoint: bool) -> {success: bool} Imports issues from the specified BCF file.

AddFilesToEmbeddedLibrary(files: [{inputPath: str, outputPath: str, type: "Window"|"Door"|"Object"}]) -> {executionResults: [{success: bool}]} Adds the given files into the embedded library.

GetLibraries() -> {libraries: [{name: str, path: str, type: str, available: bool, readOnly: bool, twServerUrl: str, urlWebLibrary: str}]} Gets the list of loaded libraries.

ReloadLibraries() -> {success: bool} Executes the reload libraries command.

GetDatabaseIdFromNavigatorItemId(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {databases: [{databaseId: {guid}}]} Gets the ID of the database associated with the supplied navigator item id

GetModelViewOptions() -> {modelViewOptions: [{name: str}]} Gets all model view options

GetView2DTransformations(databases: [{databaseId: {guid: str}}]) -> {transformations: [{}]} Get zoom and rotation of 2D views

GetViewSettings(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {viewSettings: [{}]} Gets the view settings of navigator items

PublishPublisherSet(publisherSetName: str, outputPath: str) -> void Performs a publish operation on the currently opened project. Only the given ...

Set3DCutPlanes(cutPlanes: [{pa: num, pb: num, pc: num, pd: num}]) -> {success: bool} Sets the 3D cut planes.

SetViewSettings(navigatorItemIdsWithViewSettings: [{navigatorItemId: {guid: str}, viewSettings: {modelViewOptions: str, layerCombination: str, dimensionStyle: str, penSetName: str, graphicOverrideCombination: str}}]) -> {executionResults: [{success: bool}]} Sets the view settings of navigator items

UpdateDrawings(elements: [{elementId: {guid}}]) -> {success: bool} Performs a drawing update on the given elements.

GetGeoLocation() -> {projectLocation: {longitude: num, latitude: num, altitude: num, north: num}, surveyPoint: {position: {eastings: num, northings: num, elevation: num}, geoReferencingParameters: {crsName: str, description: str, geodeticDatum: str, verticalDatum: str, mapProjection: str, mapZone: str}}} Gets the project location details.

GetHotlinks() -> {hotlinks: [{location: str, children: [...]}]} Gets the file system locations (path) of the hotlink modules. The hotlinks ca...

GetProjectInfo() -> {isUntitled: bool, isTeamwork: bool, projectLocation: str, projectPath: str, projectName: str} Retrieves information about the currently loaded project.

GetProjectInfoFields() -> {fields: [{projectInfoId: str, projectInfoName: str, projectInfoValue: str}]} Retrieves the names and values of all project info fields.

GetStories() -> {firstStory: int, lastStory: int, actStory: int, skipNullFloor: bool, stories: [{index: int, floorId: int, dispOnSections: bool, level: num, name: str}]} Retrieves information about the story sructure of the currently loaded project.

IFCFileOperation(method: "save"|"merge"|"open", ifcFilePath: str, fileType: "ifc"|"ifcxml"|"ifczip") -> {success: bool} Executes an IFC file operation.

OpenProject(projectFilePath: str) -> {success: bool} Opens the given project.

SetGeoLocation(projectLocation: {longitude: num, latitude: num, altitude: num, north: num}, surveyPoint: {position: {eastings: num, northings: num, elevation: num}, geoReferencingParameters: {crsName: str, description: str, geodeticDatum: str, verticalDatum: str, mapProjection: str, mapZone: str}}) -> {success: bool} Sets the project location details.

SetProjectInfoField(projectInfoId: str, projectInfoValue: str) -> void Sets the value of a project info field.

SetStories(stories: [{dispOnSections: bool, level: num, name: str}]) -> {success: bool} Sets the story sructure of the currently loaded project.

CreatePropertyDefinitions(propertyDefinitions: [{propertyDefinition: {name: str, description: str, type: "number"|"integer"|"string", isEditable: bool, defaultValue: {}, possibleEnumValues: [...], availability: [...], group: {propertyGroupId, name}}}]) -> {propertyIds: [{}]} Creates Custom Property Definitions based on the given parameters.

CreatePropertyGroups(propertyGroups: [{propertyGroup: {name: str, description: str}}]) -> {propertyGroupIds: [{propertyGroupId: {guid}}]} Creates Property Groups based on the given parameters.

DeletePropertyDefinitions(propertyIds: [{propertyId: {guid}}]) -> {executionResults: [{success: bool}]} Deletes the given Custom Property Definitions.

DeletePropertyGroups(propertyGroupIds: [{propertyGroupId: {guid: str}}]) -> {executionResults: [{success: bool}]} Deletes the given Custom Property Groups.

GetAllProperties() -> {properties: [{propertyId: {guid}, propertyType: "StaticBuiltIn"|"DynamicBuiltIn"|"Custom", propertyGroupName: str, propertyName: str, propertyCollectionType: "Undefined"|"Single"|"List", propertyValueType: "Undefined"|"Integer"|"Real", propertyMeasureType: "Undefined"|"Default"|"Length", propertyIsEditable: bool}]} Returns all user defined and built-in properties.

GetPropertyValuesOfAttributes(attributeIds: [{attributeId: {guid: str}}], properties: [{propertyId: {guid}}]) -> {propertyValuesForAttributes: [{}]} Returns the property values of the attributes for the given property.

GetPropertyValuesOfElements(elements: [{elementId: {guid}}], properties: [{propertyId: {guid}}]) -> {propertyValuesForElements: [{}]} Returns the property values of the elements for the given property. It works ...

SetPropertyValuesOfAttributes(attributePropertyValues: [{attributeId: {guid: str}, propertyId: {guid}, propertyValue: {value: str}}]) -> {executionResults: [{success: bool}]} Sets the property values of attributes.

SetPropertyValuesOfElements(elementPropertyValues: [{elementId: {guid}, propertyId: {guid}, propertyValue: {value: str}}]) -> {executionResults: [{success: bool}]} Sets the property values of elements. It works for subelements of hierarchal ...

GetCurrentRevisionChangesOfLayouts(layoutDatabaseIds: [{databaseId: {guid: str}}]) -> {currentRevisionChangesOfLayouts: {}} Retrieves all changes belong to the last revision of the given layouts.

GetDocumentRevisions() -> {documentRevisions: [{revisionId: {guid}, id: str, finalId: str, ownerUser: str, status: "Actual"|"Issued", changes: [...], layoutInfo: {id, databaseId, name, masterLayoutName, width, height, subsetId, subsetName, ownerUser, customSchemeData}}]} Retrieves all document revisions.

GetRevisionChanges() -> {revisionChanges: [{id: str, description: str, lastModifiedTime: str, modifiedByUser: str, isIssued: bool, firstRevisionIssueId: {guid}, isArchived: bool, customSchemeData: [...]}]} Retrieves all changes.

GetRevisionChangesOfElements(elements: [{elementId: {guid}}]) -> {revisionChangesOfElements: {}} Retrieves the changes belong to the given elements.

GetRevisionIssues() -> {revisionIssues: [{revisionIssueId: {guid}, id: str, description: str, issueTime: str, issuedByUser: str, overrideRevisionIDOfAllIncludedLayouts: bool, createNewRevisionInAllIncludedLayouts: bool, markersVisibleSinceIndex: int, isIssued: bool, documentRevisions: [...], customSchemeData: [...]}]} Retrieves all issues.

ReleaseElements(elements: [{elementId: {guid}}]) -> {success: bool} Releases elements in Teamwork mode.

ReserveElements(elements: [{elementId: {guid}}]) -> {executionResult: {success: bool}, conflicts: [{elementId: {guid}, user: {userId, userName}}]} Reserves elements in Teamwork mode.

TeamworkReceive() -> {success: bool} Performs a receive operation on the currently opened Teamwork project.

TeamworkSend() -> {success: bool} Performs a send operation on the currently opened Teamwork project.

BUILT-IN API COMMANDS

Call via: await archicad.command("API.CommandName", params)

API.ExecuteAddOnCommand(addOnCommandId: {commandNamespace: str, commandName: str}, addOnCommandParameters: AddOnCommandParameters) -> {addOnCommandResponse: {}} Executes a command registered in an Add-On.

API.IsAddOnCommandAvailable(addOnCommandId: {commandNamespace: str, commandName: str}) -> {available: bool} Checks if the command is available or not.

API.CreateAttributeFolders(attributeFolders: [AttributeFolderCreationParameters]) -> {executionResults: [ExecutionResult]} Creates attribute folders. To create a folder, its full path has to be provid...

API.DeleteAttributeFolders(attributeFolderIds: [{attributeFolderId: {guid: str}}]) -> {executionResults: [ExecutionResult]} Deletes attribute folders and all the deletable attributes and folders it con...

API.DeleteAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {executionResults: [ExecutionResult]} Deletes attributes.

API.GetActivePenTables() -> {modelViewPenTableId: {}, layoutBookPenTableId: {}} Returns the model view and layout book pen table identifiers.

API.GetAttributeFolderStructure(attributeType: "BuildingMaterial"|"Composite"|"Fill", path: [str]) -> {attributeFolder: {attributeFolderId: {guid: str}, name: str, attributes: [{attribute}], subfolders: [{attributeFolder}]}} Returns the detailed folder structure for the attributes of a given type. If ...

API.GetAttributeFolders(attributeFolderIds: [{attributeFolderId: {guid: str}}]) -> {attributeFolders: [{}]} Returns the detailed attribute folders identified by their Ids.

API.GetAttributesByType(attributeType: "BuildingMaterial"|"Composite"|"Fill") -> {attributeIds: [{attributeId: {guid}}]} Returns the identifier of every attribute of the given type.

API.GetAttributesIndices(attributeIds: [{attributeId: {guid: str}}]) -> {attributeIndicesAndGuids: [{}]} Returns the requested indices and guids of attributes.

API.GetBuildingMaterialAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed building material attributes identified by their GUIDs.

API.GetCompositeAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed composite attributes identified by their GUIDs.

API.GetFillAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed fill attributes identified by their GUIDs.

API.GetLayerAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed layer attributes identified by their GUIDs.

API.GetLayerCombinationAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed layer combination attributes identified by their GUIDs.

API.GetLineAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed line attributes identified by their GUIDs.

API.GetPenTableAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed pen table attributes (including their pens) identified b...

API.GetProfileAttributePreview(attributeIds: [{attributeId: {guid: str}}], imageWidth: int, imageHeight: int, backgroundColor: {red: num, green: num, blue: num}) -> {previewImages: [{}]} Returns the preview image of each requested profile attribute in a base64 str...

API.GetProfileAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed profile attributes identified by their GUIDs.

API.GetSurfaceAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed surface attributes identified by their GUIDs.

API.GetZoneCategoryAttributes(attributeIds: [{attributeId: {guid: str}}]) -> {attributes: [{}]} Returns the detailed zone category attributes identified by their GUIDs.

API.MoveAttributesAndFolders(attributeFolderIds: [{attributeFolderId: {guid: str}}], attributeIds: [{attributeId: {guid: str}}], targetFolderId: {guid: str}) -> void Moves attributes and attribute folders.

API.RenameAttributeFolders(attributeFolderParametersList: [AttributeFolderRenameParameters]) -> {executionResults: [ExecutionResult]} Rename attribute folder.

API.GetProductInfo() -> {version: int, buildNumber: int, languageCode: str} Accesses the version information from the running Archicad.

API.IsAlive() -> {isAlive: bool} Checks if the Archicad connection is alive.

API.GetAllClassificationSystems() -> {classificationSystems: [{classificationSystemId: {guid}, name: str, description: str, source: str, version: str, date: str}]} Returns the list of available classification systems.

API.GetAllClassificationsInSystem(classificationSystemId: {guid: str}) -> {classificationItems: [{classificationItem: {classificationItemId, id, name, description, children}}]} Returns the tree of classifications in the given classification system.

API.GetClassificationItemAvailability(classificationItemIds: [{classificationItemId: {guid: str}}]) -> {classificationItemAvailabilityList: [{}]} Returns the ids of property definitions available for a given classification ...

API.GetClassificationSystemIds() -> {classificationSystemIds: [{classificationSystemId: {guid}}]} Returns the list of available classification systems.

API.GetClassificationSystems(classificationSystemIds: [{classificationSystemId: {guid: str}}]) -> {classificationSystems: [{}]} Returns the details of classification systems identified by their GUIDs.

API.GetClassificationsOfElements(elements: [{elementId: {guid: str}}], classificationSystemIds: [{classificationSystemId: {guid: str}}]) -> {elementClassifications: [{}]} Returns the classification of the given elements in the given classification ...

API.GetDetailsOfClassificationItems(classificationItemIds: [{classificationItemId: {guid: str}}]) -> {classificationItems: [{}]} Returns the details of classification items.

API.SetClassificationsOfElements(elementClassifications: [{elementId: {guid: str}, classificationId: {classificationSystemId: {guid}, classificationItemId: {guid}}}]) -> {executionResults: [ExecutionResult]} Sets the classifications of elements. In order to set the classification of a...

API.GetComponentsOfElements(elements: [{elementId: {guid: str}}]) -> {componentsOfElements: [{}]} Returns the identifier of every component for a list of elements. The order o...

API.GetPropertyValuesOfElementComponents(elementComponents: [{elementComponentId: {elementId: {guid}, componentId: {guid}}}], properties: [{propertyId: {guid: str}}]) -> {propertyValuesForElementComponents: [{}]} Returns the property values of the components for the given property.

API.Get2DBoundingBoxes(elements: [{elementId: {guid: str}}]) -> {boundingBoxes2D: [{}]} Get the 2D bounding box of elements identified by their GUIDs. The bounding b...

API.Get3DBoundingBoxes(elements: [{elementId: {guid: str}}]) -> {boundingBoxes3D: [{}]} Get the 3D bounding box of elements identified by their GUIDs. The bounding b...

API.GetAllElements() -> {elements: [{elementId: {guid}}]} Returns the identifier of every element in the current plan.

API.GetElementsByClassification(classificationItemId: {guid: str}) -> {elements: [{elementId: {guid}}]} Returns the identifier of every element with the given classification identif...

API.GetElementsByType(elementType: "Wall"|"Column"|"Beam") -> {elements: [{elementId: {guid}}]} Returns the identifier of every element of the given type on the plan.

API.GetSelectedElements(onlyEditable: bool, onlySupportedTypes: bool) -> {elements: [{elementId: {guid}}]} Returns the identifiers of selected elements in the current plan.

API.GetTypesOfElements(elements: [{elementId: {guid: str}}]) -> {typesOfElements: [{}]} Returns the types of the given elements.

API.GetElementsRelatedToZones(zones: [{elementId: {guid: str}}], elementTypes: ["Wall"|"Column"|"Beam"]) -> {elementsRelatedToZones: [{}]} Returns related elements of the given zones. The related elements will be gro...

API.CreateLayout(layoutName: str, layoutParameters: LayoutParameters, masterNavigatorItemId: {guid: str}, parentNavigatorItemId: {guid: str}) -> {createdNavigatorItemId: {guid: str}} Creates a new layout.

API.CreateLayoutSubset(subsetParameters: {name: str, includeToIDSequence: bool, customNumbering: bool, continueNumbering: bool, useUpperPrefix: bool, addOwnPrefix: bool, customNumber: str, autoNumber: str, numberingStyle: "Undefined"|"abc"|"ABC", startAt: int, ownPrefix: str}, parentNavigatorItemId: {guid: str}) -> {createdSubsetId: {guid: str}} Creates a new layout subset.

API.GetLayoutSettings(layoutNavigatorItemId: {guid: str}) -> {layoutParameters: LayoutParameters} Returns the parameters (settings) of the given layout.

API.SetLayoutSettings(layoutParameters: LayoutParameters, layoutNavigatorItemId: {guid: str}) -> void Sets the parameters (settings) of the given layout.

API.DeleteNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {executionResults: [ExecutionResult]} Deletes items from navigator tree.

API.GetBuiltInContainerNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the built-in container navigator items identified by t...

API.GetDetailNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the detail navigator items identified by their Ids.

API.GetDocument3DNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the 3D document navigator items identified by their Ids.

API.GetElevationNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the detailed elevation navigator items identified by their Ids.

API.GetInteriorElevationNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the interior elevation navigator items identified by t...

API.GetNavigatorItemTree(navigatorTreeId: {}) -> {navigatorTree: {rootItem: {navigatorItemId: {guid}, prefix: str, name: str, type: "UndefinedItem"|"ProjectMapRootItem"|"StoryItem", sourceNavigatorItemId: {guid}, children: [...]}}} Returns the tree of navigator items.

API.GetNavigatorItemsType(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItemIdAndTypeList: [{}]} Returns all navigator item types based on the navigator item identifiers give...

API.GetPublisherSetNames() -> {publisherSetNames: [str]} Returns the names of available publisher sets.

API.GetSectionNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the section navigator items identified by their Ids.

API.GetStoryNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the story navigator items identified by their Ids.

API.GetWorksheetNavigatorItems(navigatorItemIds: [{navigatorItemId: {guid: str}}]) -> {navigatorItems: [{}]} Returns the details of the worksheet navigator items identified by their Ids.

API.MoveNavigatorItem(navigatorItemIdToMove: {guid: str}, parentNavigatorItemId: {guid: str}, previousNavigatorItemId: {guid: str}) -> void Moves the given navigator item under the parentNavigatorItemId in the ...

API.RenameNavigatorItem() -> void Renames an existing navigator item by specifying either the name or the ID, o...

API.GetAllPropertyGroupIds(propertyType: "UserDefined"|"BuiltIn") -> {propertyGroupIds: [{propertyGroupId: {guid}}]} Returns the identifier of every property group in the current plan. The optio...

API.GetAllPropertyIds(propertyType: "UserDefined"|"BuiltIn") -> {propertyIds: [{propertyId: {guid}}]} Returns the identifier of every property in the current plan. The optional pr...

API.GetAllPropertyIdsOfElements(elements: [{elementId: {guid: str}}], propertyType: "UserDefined"|"BuiltIn") -> {propertyIdsOfElements: [{}]} Returns all property identifiers of the given elements. The optional property...

API.GetAllPropertyNames() -> {properties: [{}]} Returns the human-readable names of available Property definitions for debug ...

API.GetDetailsOfProperties(properties: [{propertyId: {guid: str}}]) -> {propertyDefinitions: [{}]} Returns the details of property definitions.

API.GetPropertyDefinitionAvailability(propertyIds: [{propertyId: {guid: str}}]) -> {propertyDefinitionAvailabilityList: [{}]} Returns the ids of classification items a given property definition is availa...

API.GetPropertyGroups(propertyGroupIds: [{propertyGroupId: {guid: str}}]) -> {propertyGroups: [{}]} Returns the details of property groups.

API.GetPropertyIds(properties: [{}]) -> {properties: [{}]} Returns the identifiers of property definitions for the requested property na...

API.GetPropertyValuesOfElements(elements: [{elementId: {guid: str}}], properties: [{propertyId: {guid: str}}]) -> {propertyValuesForElements: [{}]} Returns the property values of the elements for the given property.

API.SetPropertyValuesOfElements(elementPropertyValues: [{elementId: {guid: str}, propertyId: {guid: str}, propertyValue: {}}]) -> {executionResults: [ExecutionResult]} Sets the property values of elements.

API.CloneProjectMapItemToViewMap(projectMapNavigatorItemId: {guid: str}, parentNavigatorItemId: {guid: str}) -> {createdNavigatorItemId: {guid: str}} Clones a project map item to the view map.

API.CreateViewMapFolder(folderParameters: FolderParameters, parentNavigatorItemId: {guid: str}, previousNavigatorItemId: {guid: str}) -> {createdFolderNavigatorItemId: {guid: str}} Creates a view folder item at the given position in the navigator tree.

ELEMENT TYPES

Wall, Column, Beam, Window, Door, Object, Lamp, Slab, Roof, Mesh, Dimension, RadialDimension, LevelDimension, AngleDimension, Text, Label, Zone, Hatch, Line, PolyLine, Arc, Circle, Spline, Hotspot, CutPlane, Camera, CamSet, Group, SectElem, Drawing, Picture, Detail, Elevation, InteriorElevation, Worksheet, Hotlink, CurtainWall, CurtainWallSegment, CurtainWallFrame, CurtainWallPanel, CurtainWallJunction, CurtainWallAccessory, Shell, Skylight, Morph, ChangeMarker, Stair, Riser, Tread, StairStructure, Railing, RailingToprail, RailingHandrail, RailingRail, RailingPost, RailingInnerPost, RailingBaluster, RailingPanel, RailingSegment, RailingNode, RailingBalusterSet, RailingPattern, RailingToprailEnd, RailingHandrailEnd, RailingRailEnd, RailingToprailConnection, RailingHandrailConnection, RailingRailConnection, RailingEndFinish, BeamSegment, ColumnSegment, Opening, Unknown

IMPORTANT: Element types are CASE-SENSITIVE. Use "Wall" not "wall". Invalid types return an error.

ELEMENT FILTERS

Use with GetElementsByType, GetAllElements, FilterElements: filters: ["IsEditable", "OnActualFloor"] # Array of strings, NOT objects!

Valid filters: IsEditable, IsVisibleByLayer, IsVisibleByRenovation, IsVisibleByStructureDisplay, IsVisibleIn3D, OnActualFloor, OnActualLayout, InMyWorkspace, IsIndependent, InCroppedView, HasAccessRight, IsOverriddenByRenovation

AVAILABLE MODULES (pre-imported, import x also works)

json, csv, math, pathlib (Path), re, datetime, itertools, functools, collections, statistics, copy, io, openpyxl

FILE ACCESS

Read/write access to most paths.

BLOCKED (system directories):

• /usr/*

• /bin/*

• /sbin/*

• /etc/*

• /var/*

• OS system directories

Attempting to access blocked paths raises PermissionError.

RETURNING DATA

Set result = <value> to return data. Large lists (>500 items) are auto-truncated.

COMMON PATTERNS

Get and filter elements

result = await archicad.tapir("GetElementsByType", {"elementType": "Wall"}) walls = result.get("elements", [])

Export to file

import json with open("C:/output.json", "w") as f: json.dump(walls, f)

Create elements

columns_data = [{"coordinates": {"x": i*5000, "y": 0, "z": 0}} for i in range(5)] result = await archicad.tapir("CreateColumns", {"columnsData": columns_data}) created = result.get("elements", [])

Read property values (LOCALE WARNING: numeric values may use comma decimals)

Archicad returns locale-formatted strings: "1,00" not 1.0

Always normalize before arithmetic: float(value.replace(",", "."))

Args: port: Archicad instance port (from list_instances) script: Python code to execute timeout_seconds: Optional timeout in seconds (default: no timeout)