Skip to content

glossary-term.md

Latest commit

 

History

History
1956 lines (1638 loc) · 47.6 KB

glossary-term.md

File metadata and controls

1956 lines (1638 loc) · 47.6 KB

GlossaryTerm

Business concepts and definitions - the foundation of business vocabulary

Overview

The GlossaryTerm entity represents a business concept with its definition, synonyms, related terms, and relationships to data assets. It is the primary mechanism for linking business context to technical data assets.

Relationship Diagram

graph TD
    %% Main entity
    GT[GlossaryTerm<br/>Customer]

    %% Parent glossary
    GLOSS[Glossary<br/>BusinessGlossary] -->|contains| GT

    %% Parent term hierarchy
    PARENT[GlossaryTerm<br/>Party] -->|parent of| GT

    %% Child terms
    GT -->|has child| CHILD1[GlossaryTerm<br/>EnterpriseCustomer]
    GT -->|has child| CHILD2[GlossaryTerm<br/>IndividualCustomer]
    GT -->|has child| CHILD3[GlossaryTerm<br/>VIPCustomer]

    %% Related terms
    GT -.->|related to| REL1[GlossaryTerm<br/>Order]
    GT -.->|related to| REL2[GlossaryTerm<br/>Revenue]
    GT -.->|related to| REL3[GlossaryTerm<br/>Account]

    %% Synonyms
    GT -.->|synonym| SYN1[Synonym<br/>Client]
    GT -.->|synonym| SYN2[Synonym<br/>Buyer]
    GT -.->|synonym| SYN3[Synonym<br/>Purchaser]

    %% Governance relationships
    USR[User<br/>Jane Doe] -.->|owns| GT
    REV[Team<br/>DataGovernance] -.->|reviews| GT
    DOM[Domain<br/>Sales] -.->|groups| GT

    %% Classification tags
    TAG1[Tag<br/>Governance.Approved] -.->|classifies| GT
    TAG2[Tag<br/>PII.NonSensitive] -.->|classifies| GT

    %% Applied to data assets
    GT -.->|describes| TBL1[Table<br/>customers]
    GT -.->|describes| TBL2[Table<br/>customer_accounts]
    GT -.->|describes| COL1[Column<br/>customer_id]
    GT -.->|describes| COL2[Column<br/>customer_type]
    GT -.->|describes| DASH[Dashboard<br/>Customer Analytics]
    GT -.->|describes| ML[MLModel<br/>customer_churn]

    %% External references
    GT -.->|references| REF1[External Link<br/>Wikipedia]
    GT -.->|references| REF2[External Link<br/>GDPR Docs]

    %% Styling
    classDef glossary fill:#8B5CF6,stroke:#7C3AED,color:#fff
    classDef term fill:#A78BFA,stroke:#8B5CF6,color:#fff
    classDef synonym fill:#DDD6FE,stroke:#A78BFA,color:#000
    classDef governance fill:#059669,stroke:#047857,color:#fff
    classDef data fill:#2563EB,stroke:#1E40AF,color:#fff
    classDef external fill:#64748B,stroke:#475569,color:#fff

    class GLOSS glossary
    class GT,PARENT,CHILD1,CHILD2,CHILD3,REL1,REL2,REL3 term
    class SYN1,SYN2,SYN3 synonym
    class USR,REV,DOM,TAG1,TAG2 governance
    class TBL1,TBL2,COL1,COL2,DASH,ML data
    class REF1,REF2 external
Loading

Schema Specifications

View the complete GlossaryTerm schema in your preferred format:

=== "JSON Schema"

**Complete JSON Schema Definition**

```json
{
  "$id": "https://open-metadata.org/schema/entity/data/glossaryTerm.json",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "GlossaryTerm",
  "description": "This schema defines te Glossary term entities.",
  "$comment": "@om-entity-type",
  "type": "object",
  "javaType": "org.openmetadata.schema.entity.data.GlossaryTerm",
  "javaInterfaces": ["org.openmetadata.schema.EntityInterface"],

  "definitions": {
    "termReference": {
      "type": "object",
      "properties": {
        "name": {
          "description": "Name that identifies the source of an external glossary term. Example `HealthCare.gov`.",
          "type": "string"
        },
        "endpoint": {
          "description": "Name that identifies the source of an external glossary term. Example `HealthCare.gov`.",
          "type": "string",
          "format": "uri"
        }
      },
      "additionalProperties": false
    }
  },

  "properties": {
    "id": {
      "description": "Unique identifier of a glossary term instance.",
      "$ref": "../../type/basic.json#/definitions/uuid"
    },
    "name": {
      "description": "Preferred name for the glossary term.",
      "$ref": "../../type/basic.json#/definitions/entityName"
    },
    "displayName": {
      "description": "Display Name that identifies this glossary.",
      "type": "string"
    },
    "description": {
      "description": "Description of the glossary term.",
      "$ref": "../../type/basic.json#/definitions/markdown"
    },
    "style": {
      "$ref": "../../type/basic.json#/definitions/style"
    },
    "fullyQualifiedName": {
      "description": "A unique name that identifies a glossary term. It captures name hierarchy of glossary of terms in the form of `glossaryName.parentTerm.childTerm`.",
      "$ref": "../../type/basic.json#/definitions/fullyQualifiedEntityName"
    },
    "synonyms": {
      "description": "Alternate names that are synonyms or near-synonyms for the glossary term.",
      "type": "array",
      "items": {
        "$ref": "../../type/basic.json#/definitions/entityName"
      }
    },
    "glossary": {
      "description": "Glossary that this term belongs to.",
      "$ref": "../../type/entityReference.json"
    },
    "parent": {
      "description": "Parent glossary term that this term is child of. When `null` this term is the root term of the glossary.",
      "$ref": "../../type/entityReference.json"
    },
    "children": {
      "description": "Other glossary terms that are children of this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "relatedTerms": {
      "description": "Other glossary terms that are related to this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "references": {
      "description": "Link to a reference from an external glossary.",
      "type": "array",
      "items": {
        "$ref": "../../entity/data/glossaryTerm.json#/definitions/termReference"
      }
    },
    "version": {
      "description": "Metadata version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/entityVersion"
    },
    "updatedAt": {
      "description": "Last update time corresponding to the new version of the entity in Unix epoch time milliseconds.",
      "$ref": "../../type/basic.json#/definitions/timestamp"
    },
    "updatedBy": {
      "description": "User who made the update.",
      "type": "string"
    },
    "impersonatedBy": {
      "description": "Bot user that performed the action on behalf of the actual user.",
      "$ref": "../../type/basic.json#/definitions/impersonatedBy"
    },
    "href": {
      "description": "Link to the resource corresponding to this entity.",
      "$ref": "../../type/basic.json#/definitions/href"
    },
    "reviewers": {
      "description": "User names of the reviewers for this glossary.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "owners": {
      "description": "Owners of this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "usageCount": {
      "description": "Count of how many times this and it's children glossary terms are used as labels.",
      "type": "integer"
    },
    "tags": {
      "description": "Tags associated with this glossary term. These tags captures relationship of a glossary term with a tag automatically. As an example a glossary term 'User.PhoneNumber' might have an associated tag 'PII.Sensitive'. When 'User.Address' is used to label a column in a table, 'PII.Sensitive' label is also applied automatically due to Associated tag relationship.",
      "type": "array",
      "items": {
        "$ref": "../../type/tagLabel.json"
      },
      "default": []
    },
    "changeDescription": {
      "description": "Change that lead to this version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/changeDescription"
    },
    "incrementalChangeDescription": {
      "description": "Change that lead to this version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/changeDescription"
    },
    "entityStatus": {
      "description": "Approval status of the glossary term.",
      "$ref": "../../type/status.json"
    },
    "deleted": {
      "description": "When `true` indicates the entity has been soft deleted.",
      "type": "boolean",
      "default": false
    },
    "provider": {
      "$ref": "../../type/basic.json#/definitions/providerType"
    },
    "disabled": {
      "description": "System glossary can't be deleted. Use this flag to disable them.",
      "type": "boolean"
    },
    "mutuallyExclusive": {
      "description": "Glossary terms that are children of this term are mutually exclusive. When mutually exclusive is `true` only one term can be used to label an entity from this group. When mutually exclusive is `false`, multiple terms from this group can be used to label an entity.",
      "type": "boolean",
      "default": "false"
    },
    "extension": {
      "description": "Entity extension data with custom attributes added to the entity.",
      "$ref": "../../type/basic.json#/definitions/entityExtension"
    },
    "domains": {
      "description": "Domains the Glossary Term belongs to. When not set, the Glossary TErm inherits the domain from the Glossary it belongs to.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "dataProducts": {
      "description": "List of data products this entity is part of.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "votes": {
      "description": "Votes on the entity.",
      "$ref": "../../type/votes.json"
    },
    "childrenCount": {
      "description": "Count of immediate children glossary terms.",
      "type": "integer"
    }
  },

  "required": ["id", "name", "description", "glossary"],
  "additionalProperties": false
}
```

**EntityStatus enum** (from `../../type/status.json`):
- `Draft` - Term is being defined
- `In Review` - Term is under review
- `Approved` - Term has been reviewed and approved
- `Deprecated` - Term is no longer recommended for use
- `Rejected` - Term was rejected during review
- `Unprocessed` - Default status for new terms

**[View Full JSON Schema →](https://github.com/open-metadata/OpenMetadataStandards/blob/main/schemas/entity/data/glossaryTerm.json)**

=== "RDF"

**RDF/OWL Ontology Definition**

```turtle
@prefix om: <https://open-metadata.org/schema/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2001/XMLSchema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .

# GlossaryTerm Class Definition
om:GlossaryTerm a owl:Class ;
    rdfs:subClassOf om:GovernanceAsset, skos:Concept ;
    rdfs:label "GlossaryTerm" ;
    rdfs:comment "A business concept with definition and relationships" ;
    om:hierarchyLevel 2 .

# Properties
om:termName a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:string ;
    rdfs:label "name" ;
    rdfs:comment "Name of the glossary term" .

om:fullyQualifiedName a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:string ;
    rdfs:label "fullyQualifiedName" ;
    rdfs:comment "Complete hierarchical name: glossary.term" .

om:termDefinition a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:string ;
    rdfs:label "definition" ;
    rdfs:comment "Definition of the business term" ;
    owl:equivalentProperty skos:definition .

om:synonym a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:string ;
    rdfs:label "synonym" ;
    rdfs:comment "Alternate name for this term" ;
    owl:equivalentProperty skos:altLabel .

om:entityStatus a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:EntityStatus ;
    rdfs:label "entityStatus" ;
    rdfs:comment "Approval status: Draft, In Review, Approved, Deprecated, Rejected, Unprocessed" .

om:belongsToGlossary a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:Glossary ;
    rdfs:label "belongsToGlossary" ;
    rdfs:comment "Parent glossary" ;
    owl:equivalentProperty skos:inScheme .

om:hasParentTerm a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:GlossaryTerm ;
    rdfs:label "hasParentTerm" ;
    rdfs:comment "Parent term in hierarchy" ;
    owl:equivalentProperty skos:broader .

om:hasChildTerm a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:GlossaryTerm ;
    rdfs:label "hasChildTerm" ;
    rdfs:comment "Child term in hierarchy" ;
    owl:equivalentProperty skos:narrower .

om:relatedTo a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:GlossaryTerm ;
    rdfs:label "relatedTo" ;
    rdfs:comment "Related glossary term" ;
    owl:equivalentProperty skos:related .

om:appliedToAsset a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:DataAsset ;
    rdfs:label "appliedToAsset" ;
    rdfs:comment "Data assets tagged with this term" .

om:hasOwner a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:Owner ;
    rdfs:label "hasOwner" ;
    rdfs:comment "Owners of this glossary term" .

om:belongsToDomain a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:Domain ;
    rdfs:label "belongsToDomain" ;
    rdfs:comment "Domains the glossary term belongs to" .

om:partOfDataProduct a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:DataProduct ;
    rdfs:label "partOfDataProduct" ;
    rdfs:comment "Data products this term is part of" .

om:hasVotes a owl:ObjectProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range om:Votes ;
    rdfs:label "hasVotes" ;
    rdfs:comment "Votes on the glossary term" .

om:childrenCount a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:integer ;
    rdfs:label "childrenCount" ;
    rdfs:comment "Count of immediate children glossary terms" .

om:disabled a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:boolean ;
    rdfs:label "disabled" ;
    rdfs:comment "System glossary can't be deleted. Use this flag to disable them" .

om:mutuallyExclusive a owl:DatatypeProperty ;
    rdfs:domain om:GlossaryTerm ;
    rdfs:range xsd:boolean ;
    rdfs:label "mutuallyExclusive" ;
    rdfs:comment "Whether children terms are mutually exclusive" .

# Entity Status Enumeration
om:EntityStatus a owl:Class ;
    owl:oneOf (
        om:DraftStatus
        om:InReviewStatus
        om:ApprovedStatus
        om:DeprecatedStatus
        om:RejectedStatus
        om:UnprocessedStatus
    ) .

# Example Instance
ex:customerTerm a om:GlossaryTerm, skos:Concept ;
    om:termName "Customer" ;
    om:fullyQualifiedName "BusinessGlossary.Customer" ;
    om:displayName "Customer" ;
    om:termDefinition "An individual or organization that purchases goods or services" ;
    om:synonym "Client" ;
    om:synonym "Account" ;
    om:entityStatus om:ApprovedStatus ;
    om:belongsToGlossary ex:businessGlossary ;
    om:relatedTo ex:orderTerm ;
    om:hasChildTerm ex:enterpriseCustomerTerm ;
    om:appliedToAsset ex:customersTable ;
    om:hasOwner ex:janeDoe ;
    om:hasReviewer ex:dataGovernanceTeam ;
    om:belongsToDomain ex:salesDomain ;
    om:partOfDataProduct ex:customerDataProduct ;
    om:childrenCount 3 ;
    om:mutuallyExclusive false .
```

**[View Full RDF Ontology →](https://github.com/open-metadata/OpenMetadataStandards/blob/main/rdf/ontology/openmetadata.ttl)**

=== "JSON-LD"

**JSON-LD Context and Example**

```json
{
  "@context": {
    "@vocab": "https://open-metadata.org/schema/",
    "om": "https://open-metadata.org/schema/",
    "skos": "http://www.w3.org/2004/02/skos/core#",
    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
    "xsd": "http://www.w3.org/2001/XMLSchema#",

    "GlossaryTerm": "om:GlossaryTerm",
    "Concept": "skos:Concept",
    "name": {
      "@id": "om:termName",
      "@type": "xsd:string"
    },
    "fullyQualifiedName": {
      "@id": "om:fullyQualifiedName",
      "@type": "xsd:string"
    },
    "displayName": {
      "@id": "om:displayName",
      "@type": "xsd:string"
    },
    "description": {
      "@id": "om:termDefinition",
      "@type": "xsd:string"
    },
    "definition": {
      "@id": "skos:definition",
      "@type": "xsd:string"
    },
    "synonyms": {
      "@id": "skos:altLabel",
      "@type": "xsd:string",
      "@container": "@set"
    },
    "entityStatus": {
      "@id": "om:entityStatus",
      "@type": "@vocab"
    },
    "glossary": {
      "@id": "skos:inScheme",
      "@type": "@id"
    },
    "parent": {
      "@id": "skos:broader",
      "@type": "@id"
    },
    "children": {
      "@id": "skos:narrower",
      "@type": "@id",
      "@container": "@set"
    },
    "relatedTerms": {
      "@id": "skos:related",
      "@type": "@id",
      "@container": "@set"
    },
    "owners": {
      "@id": "om:hasOwner",
      "@type": "@id",
      "@container": "@set"
    },
    "reviewers": {
      "@id": "om:hasReviewer",
      "@type": "@id",
      "@container": "@set"
    },
    "tags": {
      "@id": "om:hasTag",
      "@type": "@id",
      "@container": "@set"
    },
    "domains": {
      "@id": "om:belongsToDomain",
      "@type": "@id",
      "@container": "@set"
    },
    "dataProducts": {
      "@id": "om:partOfDataProduct",
      "@type": "@id",
      "@container": "@set"
    },
    "votes": {
      "@id": "om:hasVotes",
      "@type": "@id"
    },
    "childrenCount": {
      "@id": "om:childrenCount",
      "@type": "xsd:integer"
    },
    "disabled": {
      "@id": "om:disabled",
      "@type": "xsd:boolean"
    },
    "mutuallyExclusive": {
      "@id": "om:mutuallyExclusive",
      "@type": "xsd:boolean"
    }
  }
}
```

**Example JSON-LD Instance**:

```json
{
  "@context": "https://open-metadata.org/context/glossaryTerm.jsonld",
  "@type": ["GlossaryTerm", "Concept"],
  "@id": "https://example.com/glossary/business/Customer",

  "name": "Customer",
  "fullyQualifiedName": "BusinessGlossary.Customer",
  "displayName": "Customer",
  "description": "# Customer\n\nAn individual or organization that purchases goods or services from the company.\n\n## Key Attributes\n- Must have a unique customer ID\n- Can be individual or business entity\n- Has associated contact information",
  "entityStatus": "Approved",

  "synonyms": ["Client", "Account", "Buyer"],

  "glossary": {
    "@id": "https://example.com/glossary/business",
    "@type": "Glossary",
    "name": "BusinessGlossary"
  },

  "parent": {
    "@id": "https://example.com/glossary/business/Party",
    "@type": "GlossaryTerm",
    "name": "Party"
  },

  "children": [
    {
      "@id": "https://example.com/glossary/business/EnterpriseCustomer",
      "@type": "GlossaryTerm",
      "name": "EnterpriseCustomer"
    },
    {
      "@id": "https://example.com/glossary/business/IndividualCustomer",
      "@type": "GlossaryTerm",
      "name": "IndividualCustomer"
    }
  ],

  "relatedTerms": [
    {
      "@id": "https://example.com/glossary/business/Order",
      "@type": "GlossaryTerm",
      "name": "Order"
    },
    {
      "@id": "https://example.com/glossary/business/Revenue",
      "@type": "GlossaryTerm",
      "name": "Revenue"
    }
  ],

  "references": [
    {
      "name": "Customer Definition - Wikipedia",
      "endpoint": "https://en.wikipedia.org/wiki/Customer"
    }
  ],

  "owners": [
    {
      "@id": "https://example.com/users/jane.doe",
      "@type": "User",
      "name": "jane.doe",
      "displayName": "Jane Doe"
    }
  ],

  "reviewers": [
    {
      "@id": "https://example.com/teams/data-governance",
      "@type": "Team",
      "name": "DataGovernance"
    }
  ],

  "tags": [
    {
      "@id": "https://open-metadata.org/tags/Governance/Approved",
      "tagFQN": "Governance.Approved"
    }
  ],

  "domains": [
    {
      "@id": "https://example.com/domains/sales",
      "@type": "Domain",
      "name": "Sales"
    }
  ],

  "dataProducts": [
    {
      "@id": "https://example.com/dataProducts/customer-analytics",
      "@type": "DataProduct",
      "name": "CustomerAnalytics"
    }
  ],

  "usageCount": 45,
  "childrenCount": 2,
  "mutuallyExclusive": false
}
```

**[View Full JSON-LD Context →](https://github.com/open-metadata/OpenMetadataStandards/blob/main/rdf/contexts/glossaryTerm.jsonld)**

Use Cases

  • Define business concepts with clear definitions
  • Link business terms to technical data assets (tables, columns, dashboards)
  • Build hierarchical business vocabularies (parent-child relationships)
  • Document synonyms and alternate names
  • Track term approval status and lifecycle
  • Enable business-oriented data discovery
  • Support regulatory compliance with standardized terminology
  • Facilitate cross-team understanding of business concepts
  • Document relationships between business concepts

JSON Schema Specification

Core Properties

id (uuid)

Type: string (UUID format) Required: Yes (system-generated) Description: Unique identifier for this glossary term

{
  "id": "2b3c4d5e-6f7a-4b8c-9d0e-1f2a3b4c5d6e"
}

name (entityName)

Type: string Required: Yes Pattern: ^[^.]*$ (no dots allowed) Min Length: 1 Max Length: 256 Description: Name of the glossary term

{
  "name": "Customer"
}

fullyQualifiedName (fullyQualifiedEntityName)

Type: string Required: Yes (system-generated) Pattern: ^((?!::).)*$ Description: Fully qualified name in the format glossary.term or glossary.parentTerm.term

{
  "fullyQualifiedName": "BusinessGlossary.Customer"
}

displayName

Type: string Required: No Description: Human-readable display name

{
  "displayName": "Customer"
}

description (markdown)

Type: string (Markdown format) Required: Yes Description: Rich text definition of the business term

{
  "description": "# Customer\n\nAn individual or organization that purchases goods or services from the company.\n\n## Key Attributes\n- Must have a unique customer ID\n- Can be individual or business entity\n- Has associated contact information\n\n## Usage Guidelines\nUse this term when referring to entities that have a purchasing relationship with the company."
}

Relationship Properties

glossary (EntityReference)

Type: object Required: Yes Description: Reference to parent glossary

{
  "glossary": {
    "id": "glossary-uuid",
    "type": "glossary",
    "name": "BusinessGlossary",
    "fullyQualifiedName": "BusinessGlossary"
  }
}

parent (EntityReference)

Type: object Required: No Description: Parent glossary term in hierarchy

{
  "parent": {
    "id": "parent-term-uuid",
    "type": "glossaryTerm",
    "name": "Party",
    "fullyQualifiedName": "BusinessGlossary.Party"
  }
}

children[] (GlossaryTerm[])

Type: array of GlossaryTerm references Required: No Description: Child glossary terms

{
  "children": [
    {
      "id": "child-term-uuid-1",
      "type": "glossaryTerm",
      "name": "EnterpriseCustomer",
      "fullyQualifiedName": "BusinessGlossary.Customer.EnterpriseCustomer"
    },
    {
      "id": "child-term-uuid-2",
      "type": "glossaryTerm",
      "name": "IndividualCustomer",
      "fullyQualifiedName": "BusinessGlossary.Customer.IndividualCustomer"
    }
  ]
}

relatedTerms[] (GlossaryTerm[])

Type: array of GlossaryTerm references Required: No Description: Related glossary terms (non-hierarchical relationships)

{
  "relatedTerms": [
    {
      "id": "related-term-uuid-1",
      "type": "glossaryTerm",
      "name": "Order",
      "fullyQualifiedName": "BusinessGlossary.Order"
    },
    {
      "id": "related-term-uuid-2",
      "type": "glossaryTerm",
      "name": "Revenue",
      "fullyQualifiedName": "BusinessGlossary.Revenue"
    }
  ]
}

Semantic Properties

synonyms[] (string[])

Type: array of strings Required: No Description: Alternate names for this term

{
  "synonyms": ["Client", "Account", "Buyer", "Purchaser"]
}

references[] (TermReference[])

Type: array of reference objects Required: No Description: External references and documentation

TermReference Object:

Property Type Required Description
name string Yes Reference name
endpoint uri Yes URL to external resource 
{
  "references": [
    {
      "name": "Customer Definition - Wikipedia",
      "endpoint": "https://en.wikipedia.org/wiki/Customer"
    },
    {
      "name": "GDPR Customer Rights",
      "endpoint": "https://gdpr-info.eu/art-15-gdpr/"
    }
  ]
}

entityStatus (EntityStatus enum)

Type: string enum Required: No (default: Unprocessed) Allowed Values:

  • Draft - Term is being defined
  • In Review - Term is under review
  • Approved - Term has been reviewed and approved
  • Deprecated - Term is no longer recommended for use
  • Rejected - Term was rejected during review
  • Unprocessed - Default status for new terms
{
  "entityStatus": "Approved"
}

Governance Properties

owners[] (EntityReferenceList)

Type: array of User or Team references Required: No Description: Users or teams that own this term

{
  "owners": [
    {
      "id": "owner-uuid",
      "type": "user",
      "name": "jane.doe",
      "displayName": "Jane Doe"
    },
    {
      "id": "owner-uuid-2",
      "type": "team",
      "name": "DataGovernance",
      "displayName": "Data Governance Team"
    }
  ]
}

reviewers[] (EntityReferenceList)

Type: array of User or Team references Required: No Description: Users or teams that can review and approve this term

{
  "reviewers": [
    {
      "id": "reviewer-uuid",
      "type": "team",
      "name": "DataGovernance",
      "displayName": "Data Governance Team"
    }
  ]
}

domains[] (EntityReferenceList)

Type: array of Domain references Required: No Description: Data domains this term belongs to. When not set, the term inherits the domain from the Glossary it belongs to.

{
  "domains": [
    {
      "id": "domain-uuid",
      "type": "domain",
      "name": "Sales",
      "fullyQualifiedName": "Sales"
    },
    {
      "id": "domain-uuid-2",
      "type": "domain",
      "name": "Marketing",
      "fullyQualifiedName": "Marketing"
    }
  ]
}

tags[] (TagLabel[])

Type: array Required: No Description: Classification tags applied to the term

{
  "tags": [
    {
      "tagFQN": "Governance.Approved",
      "source": "Classification",
      "labelType": "Manual",
      "state": "Confirmed"
    }
  ]
}

dataProducts[] (EntityReferenceList)

Type: array of DataProduct references Required: No Description: List of data products this entity is part of

{
  "dataProducts": [
    {
      "id": "dataproduct-uuid",
      "type": "dataProduct",
      "name": "CustomerAnalytics",
      "fullyQualifiedName": "CustomerAnalytics"
    }
  ]
}

votes (Votes)

Type: object Required: No Description: Votes on the entity (upvotes/downvotes)

{
  "votes": {
    "upVotes": 15,
    "downVotes": 2,
    "upVoters": [
      {"id": "user-uuid-1", "type": "user", "name": "user1"},
      {"id": "user-uuid-2", "type": "user", "name": "user2"}
    ],
    "downVoters": [
      {"id": "user-uuid-3", "type": "user", "name": "user3"}
    ]
  }
}

Additional Properties

style (Style)

Type: object Required: No Description: UI style configuration for the term (color, iconURL)

{
  "style": {
    "color": "#1E88E5",
    "iconURL": "https://example.com/icons/customer.svg"
  }
}

disabled (boolean)

Type: boolean Required: No Description: System glossary can't be deleted. Use this flag to disable them.

{
  "disabled": false
}

mutuallyExclusive (boolean)

Type: boolean Required: No (default: false) Description: Glossary terms that are children of this term are mutually exclusive. When true, only one term can be used to label an entity from this group. When false, multiple terms from this group can be used to label an entity.

{
  "mutuallyExclusive": false
}

provider (ProviderType)

Type: string enum Required: No Description: Provider type (e.g., system, user)

{
  "provider": "user"
}

extension (EntityExtension)

Type: object Required: No Description: Entity extension data with custom attributes added to the entity

{
  "extension": {
    "customField1": "value1",
    "customField2": 123
  }
}

childrenCount (integer)

Type: integer Required: No (system-generated) Description: Count of immediate children glossary terms

{
  "childrenCount": 5
}

href (href)

Type: string (URI format) Required: No (system-generated) Description: Link to the resource corresponding to this entity

{
  "href": "https://example.com/api/v1/glossaryTerms/2b3c4d5e-6f7a-4b8c-9d0e-1f2a3b4c5d6e"
}

deleted (boolean)

Type: boolean Required: No (default: false) Description: When true indicates the entity has been soft deleted

{
  "deleted": false
}

changeDescription (ChangeDescription)

Type: object Required: No (system-managed) Description: Change that lead to this version of the entity

{
  "changeDescription": {
    "fieldsAdded": [{"name": "tags", "newValue": "[{\"tagFQN\":\"PII.Sensitive\"}]"}],
    "fieldsUpdated": [{"name": "description", "oldValue": "Old description", "newValue": "New description"}],
    "fieldsDeleted": [],
    "previousVersion": 1.0
  }
}

incrementalChangeDescription (ChangeDescription)

Type: object Required: No (system-managed) Description: Incremental change that lead to this version of the entity

{
  "incrementalChangeDescription": {
    "fieldsAdded": [],
    "fieldsUpdated": [{"name": "entityStatus", "oldValue": "Draft", "newValue": "Approved"}],
    "fieldsDeleted": [],
    "previousVersion": 1.5
  }
}

impersonatedBy (string)

Type: string Required: No (system-managed) Description: Bot user that performed the action on behalf of the actual user

{
  "impersonatedBy": "ingestion-bot"
}

Usage Properties

usageCount (integer)

Type: integer Required: No (system-generated) Description: Number of data assets tagged with this term

{
  "usageCount": 45
}

Versioning Properties

version (entityVersion)

Type: number Required: Yes (system-managed) Description: Metadata version number, incremented on changes

{
  "version": 2.1
}

updatedAt (timestamp)

Type: integer (Unix epoch milliseconds) Required: Yes (system-managed) Description: Last update timestamp

{
  "updatedAt": 1704240000000
}

updatedBy (string)

Type: string Required: Yes (system-managed) Description: User who made the update

{
  "updatedBy": "jane.doe"
}

Complete Example

{
  "id": "2b3c4d5e-6f7a-4b8c-9d0e-1f2a3b4c5d6e",
  "name": "Customer",
  "fullyQualifiedName": "BusinessGlossary.Customer",
  "displayName": "Customer",
  "description": "# Customer\n\nAn individual or organization that purchases goods or services from the company.",
  "entityStatus": "Approved",
  "style": {
    "color": "#1E88E5",
    "iconURL": "https://example.com/icons/customer.svg"
  },
  "synonyms": ["Client", "Account", "Buyer"],
  "glossary": {
    "id": "glossary-uuid",
    "type": "glossary",
    "name": "BusinessGlossary"
  },
  "parent": {
    "id": "parent-uuid",
    "type": "glossaryTerm",
    "name": "Party",
    "fullyQualifiedName": "BusinessGlossary.Party"
  },
  "children": [
    {
      "id": "child-uuid-1",
      "type": "glossaryTerm",
      "name": "EnterpriseCustomer",
      "fullyQualifiedName": "BusinessGlossary.Customer.EnterpriseCustomer"
    }
  ],
  "relatedTerms": [
    {
      "id": "related-uuid-1",
      "type": "glossaryTerm",
      "name": "Order",
      "fullyQualifiedName": "BusinessGlossary.Order"
    }
  ],
  "references": [
    {
      "name": "Customer Definition - Wikipedia",
      "endpoint": "https://en.wikipedia.org/wiki/Customer"
    }
  ],
  "owners": [
    {
      "id": "owner-uuid",
      "type": "user",
      "name": "jane.doe",
      "displayName": "Jane Doe"
    }
  ],
  "reviewers": [
    {
      "id": "reviewer-uuid",
      "type": "team",
      "name": "DataGovernance"
    }
  ],
  "domains": [
    {
      "id": "domain-uuid",
      "type": "domain",
      "name": "Sales"
    }
  ],
  "dataProducts": [
    {
      "id": "dataproduct-uuid",
      "type": "dataProduct",
      "name": "CustomerAnalytics"
    }
  ],
  "tags": [
    {
      "tagFQN": "Governance.Approved"
    }
  ],
  "votes": {
    "upVotes": 15,
    "downVotes": 2
  },
  "usageCount": 45,
  "childrenCount": 1,
  "mutuallyExclusive": false,
  "disabled": false,
  "version": 2.1,
  "updatedAt": 1704240000000,
  "updatedBy": "jane.doe",
  "href": "https://example.com/api/v1/glossaryTerms/2b3c4d5e-6f7a-4b8c-9d0e-1f2a3b4c5d6e",
  "deleted": false
}

RDF Representation

Ontology Class

@prefix om: <https://open-metadata.org/schema/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2001/XMLSchema#> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .

om:GlossaryTerm a owl:Class ;
    rdfs:subClassOf om:GovernanceAsset, skos:Concept ;
    rdfs:label "GlossaryTerm" ;
    rdfs:comment "A business concept with definition and relationships" ;
    om:hasProperties [
        om:name "string" ;
        om:definition "string" ;
        om:synonyms "string[]" ;
        om:status "TermStatus" ;
        om:parent "GlossaryTerm" ;
        om:children "GlossaryTerm[]" ;
        om:relatedTerms "GlossaryTerm[]" ;
    ] .

Instance Example

@prefix om: <https://open-metadata.org/schema/> .
@prefix ex: <https://example.com/glossary/> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .

ex:customerTerm a om:GlossaryTerm, skos:Concept ;
    om:termName "Customer" ;
    om:fullyQualifiedName "BusinessGlossary.Customer" ;
    om:displayName "Customer" ;
    skos:definition "An individual or organization that purchases goods or services" ;
    skos:altLabel "Client" ;
    skos:altLabel "Account" ;
    om:entityStatus om:ApprovedStatus ;
    skos:inScheme ex:businessGlossary ;
    skos:broader ex:partyTerm ;
    skos:narrower ex:enterpriseCustomerTerm ;
    skos:related ex:orderTerm ;
    om:hasOwner ex:janeDoe ;
    om:hasReviewer ex:dataGovernanceTeam ;
    om:belongsToDomain ex:salesDomain ;
    om:partOfDataProduct ex:customerDataProduct ;
    om:appliedToAsset ex:customersTable ;
    om:childrenCount 1 ;
    om:mutuallyExclusive false ;
    om:disabled false .

JSON-LD Context

{
  "@context": {
    "@vocab": "https://open-metadata.org/schema/",
    "om": "https://open-metadata.org/schema/",
    "skos": "http://www.w3.org/2004/02/skos/core#",
    "GlossaryTerm": "om:GlossaryTerm",
    "Concept": "skos:Concept",
    "name": "om:termName",
    "description": "skos:definition",
    "synonyms": "skos:altLabel",
    "glossary": "skos:inScheme",
    "parent": "skos:broader",
    "children": "skos:narrower",
    "relatedTerms": "skos:related"
  }
}

JSON-LD Example

{
  "@context": "https://open-metadata.org/context/glossaryTerm.jsonld",
  "@type": ["GlossaryTerm", "Concept"],
  "@id": "https://example.com/glossary/business/Customer",
  "name": "Customer",
  "fullyQualifiedName": "BusinessGlossary.Customer",
  "description": "An individual or organization that purchases goods or services",
  "entityStatus": "Approved",
  "synonyms": ["Client", "Account"],
  "glossary": {
    "@id": "https://example.com/glossary/business",
    "@type": "Glossary"
  },
  "parent": {
    "@id": "https://example.com/glossary/business/Party",
    "@type": "GlossaryTerm"
  },
  "owners": [
    {
      "@id": "https://example.com/users/jane.doe",
      "@type": "User",
      "name": "jane.doe"
    }
  ],
  "domains": [
    {
      "@id": "https://example.com/domains/sales",
      "@type": "Domain",
      "name": "Sales"
    }
  ],
  "childrenCount": 1,
  "mutuallyExclusive": false
}

Relationships

Parent Entities

  • Glossary: The glossary this term belongs to
  • GlossaryTerm: Parent term (for hierarchical terms)

Child Entities

  • GlossaryTerm: Child terms in hierarchy

Associated Entities

  • Owner: User or team owning this term
  • Reviewer: Users or teams that can review
  • Domain: Business domain assignment
  • Tag: Classification tags
  • DataAsset: Tables, columns, dashboards, etc. tagged with this term

Relationship Diagram

graph TD
    %% Hierarchical relationships (parent-child)
    GLOSS[Glossary<br/>BusinessGlossary] -->|contains| GT1[GlossaryTerm<br/>Customer]
    GT1 -->|has child| GT2[GlossaryTerm<br/>Individual Customer]
    GT1 -->|has child| GT3[GlossaryTerm<br/>Corporate Customer]

    %% Cross-entity relationships - Governance
    USR[User/Team] -.->|owns| GT1
    REV[User<br/>Reviewer] -.->|reviews| GT1
    DOM[Domain<br/>Sales] -.->|groups| GT1
    TAG[Tag] -.->|classifies| GT1

    %% Related terms
    GT1 -.->|related to| GT4[GlossaryTerm<br/>Account]
    GT1 -.->|synonym| SYN[Synonym<br/>Client]

    %% Cross-entity relationships - Data Assets
    GT1 -.->|describes| TBL[Table<br/>customers]
    GT1 -.->|describes| COL[Column<br/>customer_type]
    GT1 -.->|describes| DASH[Dashboard<br/>Customer Analytics]
    GT1 -.->|describes| ML[MLModel<br/>churn_predictor]

    %% Styling
    classDef glossary fill:#8B5CF6,stroke:#7C3AED,color:#fff
    classDef term fill:#A78BFA,stroke:#8B5CF6,color:#fff
    classDef governance fill:#059669,stroke:#047857,color:#fff
    classDef data fill:#2563EB,stroke:#1E40AF,color:#fff

    class GLOSS glossary
    class GT1,GT2,GT3,GT4,SYN term
    class USR,REV,DOM,TAG governance
    class TBL,COL,DASH,ML data
Loading

Custom Properties

This entity supports custom properties through the extension field. Common custom properties include:

  • Data Classification: Sensitivity level
  • Cost Center: Billing allocation
  • Retention Period: Data retention requirements
  • Application Owner: Owning application/team

See Custom Properties for details on defining and using custom properties.

API Operations

List Glossary Terms

GET /v1/glossaryTerms
Query Parameters:
  - glossary: Filter by glossary ID or name
  - parent: Filter by parent term ID
  - directChildrenOf: List immediate children of specified term
  - fields: Fields to include (children, relatedTerms, reviewers, owners, tags, usageCount, domains, dataProducts, votes, extension, childrenCount)
  - limit: Number of results (1-1000000, default 10)
  - before: Cursor for previous page
  - after: Cursor for next page
  - include: all | deleted | non-deleted (default: non-deleted)

Response: GlossaryTermList

Example Request:

GET /v1/glossaryTerms?glossary=BusinessGlossary&fields=children,relatedTerms,owners,status&limit=50

Create Glossary Term

POST /v1/glossaryTerms
Content-Type: application/json

{
  "name": "Customer",
  "displayName": "Customer",
  "description": "# Customer\n\nAn individual or organization that purchases goods or services from a business.\n\n## Key Attributes\n- Unique customer identifier\n- Contact information\n- Purchase history\n- Account status",
  "glossary": "BusinessGlossary",
  "parent": {
    "id": "parent-term-uuid",
    "type": "glossaryTerm"
  },
  "synonyms": ["Client", "Account", "Buyer"],
  "relatedTerms": [
    {
      "id": "order-term-uuid",
      "type": "glossaryTerm"
    },
    {
      "id": "revenue-term-uuid",
      "type": "glossaryTerm"
    }
  ],
  "references": [
    {
      "name": "CRM Documentation",
      "endpoint": "https://docs.example.com/crm/customer"
    }
  ],
  "entityStatus": "Draft",
  "owners": [
    {
      "id": "user-uuid",
      "type": "user"
    }
  ],
  "reviewers": [
    {
      "id": "reviewer-uuid",
      "type": "user"
    }
  ],
  "tags": [
    {"tagFQN": "Governance.Approved"},
    {"tagFQN": "PII.NonSensitive"}
  ],
  "domains": [
    {
      "id": "domain-uuid",
      "type": "domain"
    }
  ],
  "dataProducts": [
    {
      "id": "dataproduct-uuid",
      "type": "dataProduct"
    }
  ]
}

Response: GlossaryTerm

Create Multiple Glossary Terms

POST /v1/glossaryTerms/createMany
Content-Type: application/json

[
  {
    "name": "Order",
    "displayName": "Order",
    "description": "A customer's request to purchase products or services",
    "glossary": "BusinessGlossary"
  },
  {
    "name": "Invoice",
    "displayName": "Invoice",
    "description": "A document requesting payment for goods or services",
    "glossary": "BusinessGlossary"
  }
]

Response: List of created GlossaryTerms

Get Glossary Term by Name

GET /v1/glossaryTerms/name/{fqn}
Query Parameters:
  - fields: Fields to include (parent, children, relatedTerms, reviewers, owners, tags, usageCount, domains, dataProducts, votes, extension, childrenCount)
  - include: all | deleted | non-deleted (default: non-deleted)

Response: GlossaryTerm

Example Request:

GET /v1/glossaryTerms/name/BusinessGlossary.Customer?fields=parent,children,relatedTerms,usageCount

Get Glossary Term by ID

GET /v1/glossaryTerms/{id}
Query Parameters:
  - fields: Fields to include
  - include: all | deleted | non-deleted (default: non-deleted)

Response: GlossaryTerm

Update Glossary Term (Partial)

PATCH /v1/glossaryTerms/{id}
Content-Type: application/json-patch+json

[
  {
    "op": "replace",
    "path": "/entityStatus",
    "value": "Approved"
  },
  {
    "op": "add",
    "path": "/synonyms/-",
    "value": "Purchaser"
  },
  {
    "op": "replace",
    "path": "/description",
    "value": "Updated term description with additional details"
  },
  {
    "op": "add",
    "path": "/tags/-",
    "value": {"tagFQN": "BusinessCritical"}
  }
]

Response: GlossaryTerm

Create or Update Glossary Term

PUT /v1/glossaryTerms
Content-Type: application/json

{
  "name": "Revenue",
  "displayName": "Revenue",
  "description": "Income generated from normal business operations",
  "glossary": "BusinessGlossary",
  "synonyms": ["Income", "Sales"],
  "entityStatus": "Approved"
}

Response: GlossaryTerm

Delete Glossary Term

DELETE /v1/glossaryTerms/{id}
Query Parameters:
  - hardDelete: true | false (default: false - soft delete)
  - recursive: true | false (default: false)

Response: GlossaryTerm

Delete Glossary Term (Async)

DELETE /v1/glossaryTerms/async/{id}
Query Parameters:
  - hardDelete: true | false (default: false)
  - recursive: true | false (default: false)

Response: Async deletion job details

Get Assets for Term

GET /v1/glossaryTerms/{id}/assets
Query Parameters:
  - limit: Number of results (1-1000000, default 10)
  - before: Cursor for previous page
  - after: Cursor for next page

Response: List of data assets tagged with this term

Get Assets for Term by Name

GET /v1/glossaryTerms/name/{fqn}/assets
Query Parameters:
  - limit: Number of results (1-1000000, default 10)
  - before: Cursor for previous page
  - after: Cursor for next page

Response: List of data assets tagged with this term

Add Assets to Term

PUT /v1/glossaryTerms/{id}/assets/add
Content-Type: application/json

{
  "assets": [
    {
      "id": "table-uuid-1",
      "type": "table"
    },
    {
      "id": "dashboard-uuid-1",
      "type": "dashboard"
    },
    {
      "id": "column-uuid-1",
      "type": "column"
    }
  ]
}

Response: ChangeEvent

Remove Assets from Term

PUT /v1/glossaryTerms/{id}/assets/remove
Content-Type: application/json

{
  "assets": [
    {
      "id": "table-uuid-1",
      "type": "table"
    }
  ]
}

Response: ChangeEvent

Move Glossary Term (Async)

PUT /v1/glossaryTerms/{id}/moveAsync
Content-Type: application/json

{
  "newParent": {
    "id": "new-parent-uuid",
    "type": "glossaryTerm"
  }
}

Response: Async move operation details

Get Glossary Term Version

GET /v1/glossaryTerms/{id}/versions/{version}

Response: GlossaryTerm (specific version)

Get Glossary Term Versions

GET /v1/glossaryTerms/{id}/versions

Response: EntityHistory (all versions)

Search Glossary Terms

GET /v1/glossaryTerms/search
Query Parameters:
  - q: Search query
  - glossary: Filter by glossary
  - entityStatus: Filter by status (Draft, In Review, Approved, Deprecated, Rejected, Unprocessed)
  - fields: Fields to include
  - limit: Number of results
  - from: Offset for pagination

Response: SearchResults with GlossaryTerms

Example Request:

GET /v1/glossaryTerms/search?q=customer&glossary=BusinessGlossary&entityStatus=Approved&limit=20

Restore Glossary Term

PUT /v1/glossaryTerms/restore
Content-Type: application/json

{
  "id": "term-uuid"
}

Response: GlossaryTerm (restored)

Vote on Glossary Term

PUT /v1/glossaryTerms/{id}/vote
Content-Type: application/json

{
  "vote": "upvote"
}

Response: ChangeEvent

Validate Tags on Term

GET /v1/glossaryTerms/{id}/tags/validate
Query Parameters:
  - includeChildren: true | false (default: false)

Response: Validation results for tags applied to the term

Related Documentation