Sign inGet started

Workflows

Ontology Authoring and OWL Round-Trip

Goal: Import a Protégé-generated OWL ontology into OWB, edit and extend it, then export back to OWL/XML and verify round-trip fidelity.

Prerequisites

  • An OWL/XML file exported from Protégé (or any OWL-compatible tool)
  • An OWB account and workspace

Steps

1. Create a new model and import the OWL file

From the dashboard, click New model and choose Import from file.

Select OWL/XML as the format. Click Choose file and select your .owl or .xml file.

The importer previews what will be created:

  • Entity types from owl:Class declarations
  • Relationships from owl:ObjectProperty assertions
  • Data properties from owl:DatatypeProperty annotations

Review any warnings — common ones include:

WarningMeaning
Unsupported constructA complex OWL axiom (e.g. cardinality restrictions, property chains) that OWB simplifies
Blank node skippedAnonymous class expressions are not imported
Equivalent class simplifiedowl:equivalentClass with a complex expression is recorded as a semantic annotation only

Click Import to proceed.

2. Review the import summary

After import, the sidebar lists every entity type created. The workbench shows the full class hierarchy.

Check the import results:

  • Class count matches your Protégé class count (minus unsupported constructs)
  • Subclass relationships appear as parent/child links in the entity type tree
  • Object properties appear as relationships in the sidebar

If the count is lower than expected, an import warning explains which classes were skipped and why.

3. Navigate the entity type tree and verify structure

Click through the hierarchy in the sidebar. For each entity type, verify:

  • Name — matches the rdfs:label from the source ontology (or the IRI local name if no label was set)
  • Description — populated from rdfs:comment
  • isAbstract — set for classes that were declared abstract or that only appear as superclasses
  • Semantic Annotations — open the Advanced section in the panel to see disjointWith, equivalentTo, and deprecated values imported from the source

Object properties become relationships. Check that rdfs:domain and rdfs:range are correctly reflected as the relationship's source and target entity types.

4. Edit and extend the ontology

Make your changes in the workbench:

Add new classes: Click + Add entity type. Set a description, mark as abstract if appropriate, and set a parent if the new class is a subclass.

Add subclasses of existing classes: Add an entity type and set its Parent to an existing class. This emits rdfs:subClassOf in the OWL export.

Add object properties: Select the source entity type, go to Relationships, click + Add from [name], and set the target.

Add semantic annotations: Open the Advanced section of an entity type panel to set disjointWith (comma-separated class names), equivalentTo (a single class name or IRI), or mark the class as deprecated.

Add data properties: Select an entity type and use the Properties section to add fields. These export as owl:DatatypeProperty assertions.

5. Check for ontology-level issues

Click Validate in the toolbar. Beyond the standard checks, look for:

  • Impossible inheritance — a class that inherits from two disjoint classes (OWB flags this as an error)
  • Missing domain/range — a relationship with no source or target entity type
  • Circular inheritance — detected and reported with the cycle path

Resolve all errors before exporting. Warnings (e.g. a relationship without cardinality) are acceptable for ontology work where cardinality is often expressed as OWL restrictions rather than a simple 1:N label.

6. Export to OWL/XML

Click Export in the toolbar and select OWL / RDF.

The output contains:

  • owl:Class declarations for all entity types
  • rdfs:subClassOf axioms for the class hierarchy
  • owl:ObjectProperty declarations with rdfs:domain and rdfs:range
  • owl:DatatypeProperty declarations for data properties
  • owl:disjointWith, owl:equivalentClass, and owl:deprecated from semantic annotations
  • Standard OWL header with owl:Ontology declaration

Download the file. Open it in Protégé:

  1. In Protégé, go to File → Open and select the exported file
  2. Check the Classes tab — your class hierarchy should appear intact
  3. Check the Object properties tab — relationships should appear with domain and range
  4. Check the Data properties tab — scalar properties should appear
  5. Run the built-in reasoner (Reasoner → Start reasoner) to verify consistency

Any constructs OWB couldn't represent (e.g. property chains, qualified cardinality restrictions from the original file) will be absent — this is expected. The export faithfully represents what OWB models, not constructs it doesn't support.

Click Publish in the toolbar. Click Share to generate a read-only link.

Send the link to domain experts or compliance reviewers. They can browse the full class hierarchy and property definitions without logging in or needing Protégé.

What happens next

  • Automate OWL export via API — use GET /api/v1/models/{modelId}/export/owl to pull the ontology programmatically for compliance pipelines. See the API Endpoints reference.
  • Track versions — click + New snapshot before each major edit session to maintain a history of ontology states.
  • Cross-export for downstream use — from the same model, export to GraphQL SDL or HTML Docs to serve the ontology to teams that don't use OWL tooling. See the Multi-Stack Export workflow.