BIMvision is no longer just a viewer
For years, BIMvision has been primarily a tool for viewing and analysing IFC models for thousands of users. Free, lightweight, with a rich plugin ecosystem – a natural choice on Polish and European construction sites. But since March 2026, something has changed fundamentally.
The BIMvision Python API Bridge is a plugin that enables seamless communication between external Python scripts and the BIMvision platform through a simple HTTP REST API. With this plugin, BIMvision becomes programmable.
This is not a minor update. It is a change in product category – from a tool to a tool-platform. And within this change lies enormous potential for anyone who works seriously with BIM data.
How it works
The plugin introduces a simple yet powerful way to control BIMvision using Python and a REST API, allowing developers, BIM engineers, and technical teams to automate repetitive tasks, integrate BIMvision with other systems, and create custom tools tailored to their workflows.
The architecture is intentionally simple: once the plugin is installed, BIMvision exposes a local HTTP server on port 5000. An external Python script sends REST requests – and BIMvision responds: it selects elements, returns properties, changes the view, opens files. The script can run locally, from a server, from a Jupyter Notebook, from a CI/CD pipeline – from literally anywhere.
import requests
BASE = "http://localhost:5000"
# Get the list of all elements in the model
elements = requests.get(f"{BASE}/elements").json()
# Select a specific element by GlobalId
requests.post(f"{BASE}/select", json={"globalId": "3Kx9Az7Bm..."})
# Get properties of the selected element
props = requests.get(f"{BASE}/element/properties").json()
print(props["Pset_WallCommon"]["IsExternal"])No need to write a plugin in C++. No need to know the SDK. All it takes is Python and a basic understanding of REST.
Six directions of application
1. Automated IFC model validation
This is the most obvious and immediately valuable application. Instead of manually browsing a model for missing attributes, a Python script iterates over all elements via the API, checks the required properties, and generates a report.
missing = []
for el in requests.get(f"{BASE}/elements?ifcClass=IfcWall").json():
props = requests.get(f"{BASE}/element/{el['id']}/properties").json()
if "Width" not in props.get("Pset_WallCommon", {}):
missing.append({
"globalId": el["globalId"],
"storey": el["storey"],
"issue": "missing wall thickness"
})
# Highlight all non-compliant elements in the model
requests.post(f"{BASE}/select/multiple",
json={"globalIds": [m["globalId"] for m in missing]})The result: the model highlights non-compliant elements instantly in 3D context, not in a dry spreadsheet. This is an IDS Checker written by the user, tailored to their own standards, without the constraints of an off-the-shelf product.
2. Automated quantity take-offs and cost estimation
This is where a natural bridge to BIMestiMate comes in. A Python script queries BIMvision for element geometry and properties, processes them, and passes them to the estimating system – without manual export, without mapping in Excel.
slabs = requests.get(f"{BASE}/elements?ifcClass=IfcSlab").json()
items = []
for slab in slabs:
geo = requests.get(f"{BASE}/element/{slab['id']}/geometry").json()
props = requests.get(f"{BASE}/element/{slab['id']}/properties").json()
items.append({
"type": props.get("PredefinedType", "FLOOR"),
"material": props.get("IfcMaterial", {}).get("name", "?"),
"thickness": props.get("Pset_SlabCommon", {}).get("Width", 0),
"area_m2": geo.get("area", 0),
"volume_m3": geo.get("volume", 0),
"storey": slab.get("storey"),
})
# Send to BIMestiMate API
requests.post("https://api.bimestimate.pl/v1/takeoff",
json={"project_id": "PRJ-2026-041", "elements": items})Without Python Bridge, this kind of integration required exporting to IFC, importing into the estimating system, and manually mapping attributes. Now it is a single script.
3. Integration with AI and large language models
This is the direction that opens up entirely new possibilities. Python Bridge enables building AI assistants that can see the BIM model and answer questions about specific elements.
import anthropic
def ask_about_model(question: str) -> str:
elements = requests.get(f"{BASE}/elements/summary").json()
selected = requests.get(f"{BASE}/selection/properties").json()
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=1000,
system=f"""You are a BIM model analysis assistant.
The current model contains: {elements['summary']}.
Selected element: {selected}.""",
messages=[{"role": "user", "content": question}]
)
return response.content[0].text
print(ask_about_model(
"Does this wall meet thermal insulation requirements for climate zone III?"
))The result: the AI assistant answers questions contextualised to the specific element the user is currently viewing in the model. Not in general terms – about this particular element, with its dimensions, material, and location. This is the vision of AI-assisted BIM review that can now be built in a few hundred lines of Python.
4. Automated reporting and documentation
Regularly produced reports – element schedules, clash lists, inspection status reports – can be fully automated. A script runs on a schedule (cron, GitHub Actions, Airflow), opens the model via the API, generates the report, and sends it by email or to a CDE system.
def weekly_report(ifc_file: str):
requests.post(f"{BASE}/model/open", json={"path": ifc_file})
stats = {
"total_elements": len(requests.get(f"{BASE}/elements").json()),
"walls_no_material": validate_materials("IfcWall"),
"slabs_no_thickness":validate_thickness("IfcSlab"),
"clashes": len(requests.get(f"{BASE}/clashes").json()),
}
# Save a 3D view snapshot
requests.post(f"{BASE}/view/screenshot",
json={"path": "/tmp/snapshot.png", "width": 1920})
return statsA report that previously required an hour of a BIM manager’s work now generates automatically every night.
5. Integration with GIS and spatial data
One of the most promising directions is the integration of BIM models with geospatial data. Python Bridge acts as a bridge between BIMvision and GIS systems, enabling workflows that were previously impossible without complex custom development.
A script can query BIMvision for infrastructure elements, retrieve their geometry and bounding boxes, and then cross-reference them against spatial datasets – such as national road registries, utility networks, or land registers – using standard geospatial libraries.
import geopandas as gpd
from shapely.geometry import box
# Get all bridges from the BIM model
bridges_bim = requests.get(f"{BASE}/elements?ifcClass=IfcBridge").json()
# Load GIS dataset (e.g. national road register)
bridges_gis = gpd.read_file("road_register_bridges.gpkg")
for bridge in bridges_bim:
geo = requests.get(f"{BASE}/element/{bridge['id']}/geometry").json()
bbox = box(geo["bbox"]["minX"], geo["bbox"]["minY"],
geo["bbox"]["maxX"], geo["bbox"]["maxY"])
# Find spatial candidates in GIS
candidates = bridges_gis[bridges_gis.geometry.intersects(bbox)]
if len(candidates) == 1:
print(f"BIM element {bridge['globalId']} matched to"
f" GIS feature {candidates.iloc[0]['feature_id']}")This kind of spatial cross-referencing opens the door to a wide range of applications: automated compliance checking against zoning plans, enriching BIM elements with administrative data, detecting discrepancies between design models and official registers, or generating geo-referenced cost estimates that account for site-specific conditions such as ground category, flood zones, or access constraints.
Python Bridge removes the technical barrier between BIM and GIS that has historically required either expensive bespoke integration or significant manual effort. With a few dozen lines of Python, both worlds can share data in a single automated workflow.
6. Testing and CI/CD for BIM models
The most technically demanding but highly valuable direction: automated model quality testing as part of the documentation delivery pipeline. Every commit of a new IFC version triggers a test – the model is opened via the API, validated against a set of rules, and the result is recorded in the version control system.
# test_model_quality.py - triggered by GitHub Actions
import pytest
def test_all_walls_have_material():
walls = requests.get(f"{BASE}/elements?ifcClass=IfcWall").json()
no_mat = [w for w in walls
if not requests.get(f"{BASE}/element/{w['id']}/material").json()]
assert len(no_mat) == 0, f"{len(no_mat)} walls without material assigned"
def test_no_elements_outside_storeys():
no_storey = requests.get(f"{BASE}/elements?storey=null").json()
assert len(no_storey) == 0, \
f"{len(no_storey)} elements not assigned to any storey"A BIM model treated like code – with tests, CI/CD, and automatic rejection if quality requirements are not met. This is the digital maturity of the design process.
Who is it for
Python Bridge is a tool for three groups that have historically operated separately.
- BIM engineers – who know the model, know what they want to check, but had to do it manually. Now they can describe their knowledge as a script and run it automatically. No C++ plugin development, no SDK, no fighting with native APIs.
- Developers and system integrators – who build systems around BIM: estimating tools, CAFM, GIS platforms, investor portals. They now have a standard HTTP endpoint to write against without needing to build a BIMvision plugin.
- Researchers and data scientists – working with IFC data: machine learning on building models, element graph analysis, semantic enrichment. Python Bridge provides access to model data without parsing the IFC file from scratch.
Limitations worth knowing
Python Bridge runs locally – which is both an advantage (data security, no cloud dependency) and a limitation (the script must run on the machine where BIMvision is running, and only a single instance is supported). Server-side scenarios without a GUI require additional configuration.
The REST API exposes the data that BIMvision itself processes – if the IFC model contains inconsistencies or gaps, the API will return those inconsistencies. Garbage in, garbage out: Python Bridge does not fix poor-quality models, it only makes programmatic processing easier.
The API is under active development – BIMvision regularly increments the API version, meaning scripts written today may require updates in the future. It is worth building with an abstraction layer.
Conclusion
Python Bridge is one of those plugins that changes the way you think about a product, not just its feature set. BIMvision stops being a model viewer and becomes a programmable node in the digital construction process.
For an industry that desperately needs automation and integration between systems – and that has tens of thousands of professionals across Europe who already know Python from other fields – this is a natural entry point into the world of BIM as a platform.
All the scenarios described in this article – IDS validation, quantity take-off, AI assistant, automated reporting, GIS integration, CI/CD for models – are achievable today. Not as a research project, but as a production tool, in a reasonable timeframe, by an engineer who knows Python.
This is one of those rare moments when a new tool genuinely opens doors that did not exist before.
Andrzej Tomana is the CEO of Datacomp IT, creator of BIMestiMate and BIMvision, and author of the first Polish monograph on BIM.
Contact: andrzej.tomana@datacomp.pl