A Quick-Start Guide to the Advance Design API

Modern engineering software is less and less often an isolated, closed tool. Developers of CAD, BIM, and CAE systems are opening their applications to external integrations, enabling the automation of repetitive tasks and the combination of different tools into a coherent working environment. One example of this trend is Advance Design – Graitec’s software for structural analysis and design using the finite element method (FEM), which gained an open API with version 2027.

This article aims to introduce this topic in a few steps. First, it explains what an API is in general and how it works in computing, regardless of the specific product. Next, it discusses the Advance Design API – its architecture, capabilities, and documentation sources. Finally, it presents how AI-based tools capable of writing code can support engineers in creating models and automating calculations through this API.

1. What Is an API? General Definition and Application

An API (Application Programming Interface) is a set of rules, definitions, and tools that allow one program to communicate with another program in a standardized way. In other words, an API defines what requests an external program can send to a given application, what data it must provide, and what kind of response it can expect.

The simplest analogy is a restaurant menu. The customer (the external program) does not enter the kitchen (the interior of the application) to prepare the dish themselves – instead, they place an order according to the items on the menu (the API), and the kitchen (the application) prepares and returns the finished product. The customer does not need to know exactly how the dish is prepared – it is enough to know the available menu items and how to order them.

1.1. What Is an API Used For?

• Automation – allows manual, repetitive tasks to be replaced with programmatically executed scripts.
• System integration – enables data exchange between different applications (e.g., CAD, BIM, ERP, spreadsheets) without manually exporting and importing files.
• Extensibility – external developers can build their own tools and plug-ins based on the application’s functions, without access to its source code.
• Process scalability – the same task can be performed simultaneously for multiple data variants (e.g., dozens of structural variants) without additional manual effort.
• Data consistency – eliminates errors resulting from manually retyping or copying data between systems.

1.2. Types of APIs and Key Concepts

In engineering and IT practice, the most common type of API is REST (Representational State Transfer). This is an architecture in which communication takes place using the standard HTTP protocol – the same one that handles traffic in web browsers. The key concepts related to REST APIs include:

• Request and response – the client sends a request to the server (e.g., “create a new element”), and the server returns a response with a result or data.
• Endpoints – specific URLs at which individual API functions are available (e.g., creating a project, defining loads).
• JSON (JavaScript Object Notation) data format – a lightweight, human-readable, and machine-processable data exchange format, now the standard in most APIs.
• OpenAPI specification (formerly Swagger) – a standardized, self-describing description of all available API functions, on the basis of which documentation and ready-made client code in various programming languages can be generated automatically.
• API key/token – an authentication mechanism that allows the server to verify who is sending the request and with what permissions.

Because REST APIs are based on widely used standards (HTTP, JSON, OpenAPI), virtually any programming language capable of sending network requests can be used to communicate with any application that exposes such an interface – Python, C#, JavaScript, Java, or Go.

2. The API in Advance Design

With the release of Advance Design 2027, Graitec introduced the Advance Design Open API – an open REST interface that turns Advance Design from a standalone FEM application into a programmable platform for structural analysis.

Until now, engineers have used FEM software almost exclusively through the graphical interface – every member, support, load case, or combination had to be defined manually inside the application. This works well for individual, one-off projects, but for repetitive, parametric, or strongly data-dependent work, manual handling becomes a bottleneck in the process. The Open API changes this model – Advance Design becomes a “calculation engine” that responds to instructions sent from outside, e.g., from a Python script, a C# application, a BIM integration tool, or an optimization algorithm.

2.1. Where to Find the Documentation and How to Get Started

To use the Open API, an installed copy of Advance Design 2027 is required – the API server is part of the product installation. Full documentation, the OpenAPI schema, ready-made examples in Python and C#, and a Python client library are publicly available in the official Graitec repository on GitHub:

https://github.com/Graitec-Group/advance-design-api

2.2. What the API Allows

Graitec is gradually opening up the API, adding more and more capabilities for users. All functionalities opened for external use are described by the software vendor in the GitHub folder named README.md.

2.2.1. Advance Design 2027

In Advance Design 2027, the API is open to the functionalities described below.

The reader will find a more detailed description by clicking the link v2027/README.md, and then docs/Summary.md and docs/HELP.md.

2.2.2. API in Advance Design 2027.1

In future versions of the program, Graitec will open up the API to an increasing number of commands. Major changes are planned in this area in Advance Design 2027.1, where the biggest new feature (in the author’s opinion) will be the ability to modify elements. Until now, it has only been possible to model them, with modification not being possible.

The planned new features in the Open API are presented below.

• Updating existing model objects
• Deleting structural objects
• Extended access to element and result properties
• Automatic generation of load combinations
• Managing object selection
• Managing the structural system
• User-defined cross-sections
• Integration with steel structure design

2.3. Open API vs. Graitec Assistant – Two Different Mechanisms

It is worth distinguishing the Open API from the second new feature introduced in Advance Design 2027 – the built-in AI assistant, Graitec Assistant. While the Open API is a programming interface intended for developers and teams building their own automations outside the application, Graitec Assistant is an AI engine integrated directly into the Advance Design interface, aware of the model and the user’s working context. Among other things, this assistant can answer questions about the program’s logic and results, connect to company documentation (e.g., SharePoint), and – once conversational AI is linked to the model – perform direct actions on the model, such as creating elements, defining loads, or validating data, within so-called Skills, i.e., repeatable, structured workflows.

3. Using the Advance Design API with AI Assistance

The open architecture of the Advance Design API – based on REST, JSON, and the self-describing OpenAPI specification – makes it an interface particularly well suited to working with AI assistants. The AI assistant does not replace the API itself (it does not “call” it directly over the internet, since the Advance Design API server runs locally, on the engineer’s computer, inside their own network), but it can act as an “on-demand programmer” that instantly translates an engineering need described in natural language into ready, working code that uses this API.

3.1. Typical Workflow with AI

• Description of the task in natural language – the engineer describes what needs to be done, e.g., “create a Python script that generates a steel frame for a hall with a span of 24 m, a height of 8 m, and frames spaced 6 m apart”
• Providing API context – for the generated code to match the actual Advance Design endpoints, it is worth providing the AI with the OpenAPI schema or examples from the GitHub repository (e.g., by pasting documentation excerpts or pointing to specific endpoints) – the AI can then match its calls to the actual structure of the API instead of guessing its shape.
• Generating client code – on this basis, the AI prepares a script (e.g., in Python) that sends HTTP requests to the local Advance Design API server: creating a project, defining materials and cross-sections, generating geometry, applying loads, etc. (everything the API allows).
• Running it on the engineer’s side – the engineer runs the generated script locally, on a computer with the Advance Design 2027 server installed and running – this is the stage at which the actual connection to the API is made and operations are performed on the model.
• Iterative refinement and expansion – if the script’s output (an error message, an incorrect server response) is fed back to the AI, the assistant can diagnose the problem and propose a fix, which significantly speeds up the integration process compared with searching through the documentation manually.

3.2. Limitations and Practical Notes

• No direct access to the local API – the AI, running in a browser or application, does not connect on its own to the Advance Design server running on the engineer’s computer (which is usually outside the public network). The AI’s role is to prepare and help debug the code, while the actual API call is made locally, on the user’s side.
• The importance of precise context – the quality of the generated code depends on how accurately the API schema is described (endpoint names, request and response structure). It is worth relying on the official OpenAPI schema and examples from the Graitec repository, rather than solely on the assistant’s general knowledge.
• Verification of engineering results – automation speeds up the generation of models and variants, but final responsibility for the engineering correctness of the results (compliance with standards, physical soundness of the structure) always remains with the engineer leading the project.

4. AI-Assisted Use of the API

Most structural designers are not programmers – and they don’t need to be. Writing correctly functioning code requires time and skills that a structural engineer often simply does not have, and has no need to acquire. Any AI tool capable of generating code can help: it is enough to describe what you want to achieve, and the tool will write the code itself, prepare a preview of the structure, and – using the Advance Design API – pass the result directly to the program.

This allows the engineer to focus on what they do best – designing and analyzing structures – rather than learning to program. AI becomes a kind of “translator” between an idea and working code, opening up access to calculation automation even for people without programming experience.

4.1. Procedure

The entire process of using the API with AI assistance looks almost identical every time and is presented in the infographic below.

Below is a more detailed description of the process, using a structure generator as an example.

1. Defining the Scope and Requirements

Determining the type of structure to be generated (e.g., steel hall, reinforced concrete building, shelter, truss)

Establishing the input parameters (span, height, number of storeys, loads, material)

Defining the expected result (3D model, a file ready for calculation in Advance Design, a report)

2. Preparing the Description/Prompt for the AI

Formulating a clear description of the structure in natural language (e.g., “a 20×40 m steel hall, columns every 6 m, a 10° dual-pitch roof”)

Optionally adding technical context (standards, section classes, typical structural solutions)

Optionally: preparing sample prompts/templates to help the AI understand the intent

3. Generating Code with AI

The AI translates the description into code (e.g., Python) using the Advance Design API

The code defines the geometry: nodes, members, slabs, supports

The code defines the loads and their combinations (optional)

4. Verification and Preview of the Generated Model

Visualization of the structure before sending it to Advance Design (e.g., a simple 3D preview in the script)

Checking the correctness of the geometry and structural logic, by the AI or the user

Possibility of iteratively refining the prompt if the result deviates from expectations

5. Connecting to Advance Design via the API

Sending the generated code/data to the Advance Design API

Creating the FEM model in the program based on the data from the AI

Mapping parameters (cross-sections, materials, boundary conditions) to the corresponding objects in Advance Design

Summary

An API is a universal mechanism for communication between applications, which in the case of Advance Design – thanks to a modern REST architecture, the JSON format, and the OpenAPI specification – opens up the FEM software to automation, integration with BIM systems, and the development of custom engineering tools. The Advance Design Open API provides a full range of key operations: from project management, through structural modeling and load definition, to running analyses and exporting results. Combined with AI assistants, the process of building integrations and automations becomes significantly faster and more accessible – an engineer can describe their needs in natural language, and the AI prepares ready-to-run code, paving the way for fully parametric, data-driven structural design processes.