Try Lara Translate now!
Docs
Get Credentials
  1. SDK Reference

Manage Glossaries

Lara’s Glossaries feature gives you full control over domain-specific terminology to ensure consistent, predictable, and brand-aligned translations across your applications.

📘

Available on paid plans

This feature is currently available only on Lara paid plans. See plans & pricing.

Glossary Models

Lara glossaries are multilingual. In both glossary models, a single glossary can contain terms in more than two languages. Lara supports two glossary models: monodirectional glossaries and multidirectional glossaries.

The difference between the two models is how Lara applies those terms across translation directions. A direction is a specific source-to-target language path, such as en-US → fr-FR or fr-FR → en-US.

Monodirectional glossaries

Use a monodirectional glossary when you want strict control from one source language to one or more target languages.

Each entry defines how a term in the source language should be translated into the target language or target languages. Lara applies the glossary only from the source language to the target languages, not in reverse and not between target languages.

Example:

en-US,fr-FR,it-IT
apple,pomme,mela

This glossary can be used for:

  • en-US → fr-FR
  • en-US → it-IT

It is not used for:

  • fr-FR → en-US
  • it-IT → en-US
  • fr-FR → it-IT

Multidirectional glossaries

You can upload multidirectional and multilingual glossaries using either CSV or TBX format. Unlike unidirectional glossaries, a multidirectional glossary automatically matches all language combinations present within the file.

Example:

guid,en-US,fr-FR,it-IT
g_1,apple,pomme,mela

For example, if your glossary file includes en-US, fr-FR, and it-IT, Lara will automatically apply terminology matching for:

en-US ↔ fr-FR

en-US ↔ it-IT

fr-FR ↔ it-IT

Language codes must strictly match Lara's supported language codes (e.g., en, es, fr, en-US, it-IT).

ModelCan include multiple languages?How entries are appliedBest for
MonodirectionalYesFrom one source language to one or more target languages onlyControlled source-to-target terminology
MultidirectionalYesAcross all language combinations in the same entryShared multilingual concepts reusable in any direction

Whether you're managing product terminology, legal vocabulary, marketing copy, or technical terms, Lara ensures your preferred terminology is enforced across translations, documents, and API workflows.

With this feature, you can:

  • List existing glossaries to manage your translation assets.
  • Create new glossaries tailored to specific projects or clients.
  • Update glossary names to keep your workspace organized.
  • Delete glossaries that are no longer needed.
  • Add or replace entries programmatically.
  • Import terms via CSV in monodirectional or multidirectional format.
  • Check the status of your imports.
  • Export glossaries for backup or reuse.

All glossary functionalities are accessible via the same Translator (lara in the examples below) object used for translation.

Glossary object

The Glossary object describes a glossary resource and its metadata.

FieldTypeDescription
idStringUnique ID of the glossary. Format: gls_xyz123
nameStringCustom name of the glossary; it can be any string, including spaces, special characters, and non-Latin alphabets. Max length: 250 characters.
created_atDateTimeWhen the glossary is created
updated_atDateTimeWhen the glossary is last updated (equal to created_at with no updates)
owner_idStringUser who owns the glossary. Format: acc_123xyz

List Glossaries

Lists all glossaries available to the user

# List all glossaries available to the user
glossaries = lara.glossaries.list()
// List all glossaries available to the user
const glossaries = await lara.glossaries.list();
// List all glossaries available to the user
List<Glossary> glossaries = lara.glossaries.list();
// List all glossaries available to the user
$glossaries = $lara->glossaries->getAll();
// List all glossaries available to the user
glossaries, _ := lara.Glossaries.List()
// List all glossaries available to the user
val glossaries: List<Glossary> = lara.glossaries.list()
// List all glossaries available to the user
var glossaries = await lara.Glossaries.List();
// List all glossaries available to the user
let glossaries = try await lara.glossaries.list()

Create new Glossary

Creates a new glossary with a custom name.

# Create a new empty glossary with name 'Glossary 1'
glossary = lara.glossaries.create('Glossary 1')
// Create a new empty glossary with name 'Glossary 1'
const glossary = await lara.glossaries.create('Glossary 1');
// Create a new empty glossary with name 'Glossary 1'
Glossary glossary = lara.glossaries.create("Glossary 1");
// Create a new empty glossary with name 'Glossary 1'
$glossary = $lara->glossaries->create('Glossary 1');
// Create a new empty glossary with name 'Glossary 1'
newGlossary, _ := lara.Glossaries.Create("Glossary 1")
// Create a new empty glossary with name "Glossary 1"
val glossary: Glossary = lara.glossaries.create("Glossary 1")
// Create a new empty glossary with name 'Glossary 1'
var glossary = await lara.Glossaries.Create("Glossary 1");
// Create a new empty glossary with name 'Glossary 1'
let glossary = try await lara.glossaries.create(name: "Glossary 1")
FieldTypeRequiredDefaultDescription
nameStringYes
The name of the new glossary

Update Glossary Name

Updates the name of a specific glossary

# Update glossary name
updated_glossary = lara.glossaries.update('gls_1...', 'New Name for my glossary')
// Update glossary name
const updatedGlossary = await lara.glossaries.update('gls_1...', 'New Name for my glossary');
// Update glossary name
Glossary updatedGlossary = lara.glossaries.update("gls_1...", "New Name for my glossary");
// Update glossary name
$updatedGlossary = $lara->glossaries->update('gls_1...', 'New Name for my glossary');
// Update glossary name
updatedGlossary, _ := lara.Glossaries.Update("gls_1...", "New Name for my glossary")
// Update glossary name
val updatedGlossary: Glossary = lara.glossaries.update("gls_1...", "New Name for my glossary")
// Update glossary name
var updatedGlossary = await lara.Glossaries.Update("gls_1...", "New Name for my glossary");
// Update glossary name
let updatedGlossary = try await lara.glossaries.update(id: "gls_1...", name: "New Name for my glossary")
FieldTypeRequiredDefaultDescription
idStringYes
The unique identifier of the glossary to update. Format: gls_xyz123
nameStringYes
The new name for the glossary

Delete Glossary

Deletes a specific glossary

# Delete a glossary
deleted_glossary = lara.glossaries.delete('gls_1...')
// Delete a glossary
const deletedGlossary = await lara.glossaries.delete('gls_1...');
// Delete a glossary
Glossary deletedGlossary = lara.glossaries.delete("gls_1...");
// Delete a glossary
$deletedGlossary = $lara->glossaries->delete('gls_1...');
// Delete a glossary
deletedGlossary, _ := lara.Glossaries.Delete("gls_1...")
// Delete a glossary
val deletedGlossary: Glossary = lara.glossaries.delete("gls_1...")
// Delete a glossary
var deletedGlossary = await lara.Glossaries.Delete("gls_1...");
// Delete a glossary
let deletedGlossary = try await lara.glossaries.delete(id: "gls_1...")
FieldTypeRequiredDefaultDescription
idStringYes
The unique identifier of the glossary to delete. Format: gls_xyz123

Add or replace Glossary Entry

Add or replace a specific glossary entry


lara.glossaries.add_or_replace_entry(
                glossary.id,
                [
                    GlossaryTerm(language=source, value="cat"),
                    GlossaryTerm(language=target, value="gatto"),
                ],
            )
// Add or replace a mono-directional entry from a Glossary
lara.glossaries.addOrReplaceEntry(glossary.id, [
        { language: source, value: "cat" },
        { language: target, value: "gatto" }
      ])

// Add or replace a multi-directional entry from a  Glossary
lara.glossaries.addOrReplaceEntry(glossary.id, [
  { language: source, value: "cat" },
  { language: target, value: "gatto" }
], 'guid')

// Add or replace a mono-directional entry from a Glossary
lara.glossaries.addOrReplaceEntry(glossary.getId(), Arrays.asList(
    new GlossaryTerm(source, "cat"),
    new GlossaryTerm(target, "gatto")
));

// Add or replace a multi-directional entry from a  Glossary
lara.glossaries.addOrReplaceEntry(glossary.getId(), Arrays.asList(
    new GlossaryTerm(source, "cat"),
    new GlossaryTerm(target, "gatto")
), "guid");

$lara->glossaries->addOrReplaceEntry($glossary->getId(), [
            ['language' => $source, 'value' => 'cat'],
            ['language' => $target, 'value' => 'gatto']
        ]);


// Sdk available soon


// Sdk available soon


var terms = new List<GlossaryTerm>
                    {
                        new("en-US", "computer"),
                        new("it-IT", "computer")
                    };
await lara.Glossaries.AddOrReplaceEntry(glossaryId, terms);


// Sdk available soon

Delete Glossary Entry

Delete a specific glossary entry


lara.glossaries.delete_entry(
                glossary.id,
                term=GlossaryTerm(language=source, value="cat"),
            )
// Delete a mono-directional entry from a glossary
await lara.glossaries.deleteEntry(glossary.id, {language: source, value: "cat"});

// Delete a multi-directional entry from a glossary
await lara.glossaries.deleteEntry(glossary.id, null, "guid");
// Delete mono-directional entry from a glossary
lara.glossaries.deleteEntry(glossary.getId(), new GlossaryTerm(source, "cat"));
  
// Delete multi-directional entry from a glossary
lara.glossaries.deleteEntry(glossary.getId(), "guid");



$lara->glossaries->deleteEntry($glossary->getId(), ['language' => $source, 'value' => 'cat']);


// Sdk available soon


// Sdk available soon


await lara.Glossaries.DeleteEntry(glossaryId, new GlossaryTerm("en-US", "computer"));

// Delete entry on monodirectional Glossary
lara.glossaries.deleteEntry(glossary.id, { language: source, value: "cat" })

// Delete entry on multidirectional Glossary
lara.glossaries.deleteEntry(glossary.id, 'guid')

Import file to Glossary

You can import a CSV or TBX file into an existing glossary to bulk upload terms. Currently, Lara supports both monodirectional and multidirectional glossaries.

A unidirectional glossary unit consists of a list of glossary terms that work in one direction only — from a defined source term to one or more target terms. The first column defines the source language, and all other columns are target languages.

Unidirectional entries are uniquely identified by the combination of the source language and the source term. That tuple acts as the key.

Lara Glossary Format Specification

Lara supports two file formats (CSV and TBX) across two glossary types:

  • Monodirectional (CSV): The source language is specified first (first column in CSV).
  • Multidirectional (CSV & TBX): Entries are defined with a unique identifier (guid/id column in CSV, id attribute on <termEntry> in TBX), followed by language values.

For the full list of supported language codes, see here

Monodirectional CSV

Monodirectional glossaries work in one direction only, from a source term to one or more target terms.

CSV

Header row

The first row must contain valid language codes.

  • The first column is always the source language.
  • All other columns are target languages.

Example header:

en-US,fr-FR,it-IT

Row structure

Each row defines one source term and its translations.

Example:

en-USfr-FRit-IT
applepommemela

Behavior:

  • Matches: apple (en-US) → pomme (fr-FR)
  • Matches: apple (en-US) → mela (it-IT)
  • Does not match reverse or target-to-target directions

Requirements:

  • Each row must include a source term and at least one target term.
  • Empty cells are allowed, but at least one target term per row is required.

Need a ready-to-use example?
Download the template for monodirectional glossary.

The zip file includes a CSV template and an instructions.txt file explaining the template structure.

Multidirectional CSV

Multidirectional glossaries apply across all language combinations inside the file.

Each row represents one multilingual concept, identified by a unique ID.

Header row

The first column must be an entry identifier column.

The column name must be either:

  • guid
  • id

No other column names are allowed for the entry identifier.

Columns 2..N must contain valid Lara supported language codes (e.g. en, en-US, fr-FR, it-IT).

Language codes:

  • Must match exactly the supported language codes in Lara
  • Must not be duplicated
  • Order does not matter
  • At least two language columns are required

Example header:

guid,en-US,fr-FR,it-IT

Row structure

Each row must provide:

  • a non-empty guid
  • at least two non-empty language values (so the entry can work in at least one direction)

Example:

guiden-USfr-FRit-IT
g_1applepommemela

file:

guid,en-US,fr-FR,it-IT g_1,apple,pomme,mela

Behavior:

This single row applies to all combinations among the provided languages:

  • en-US → fr-FR, fr-FR → en-US
  • en-US → it-IT, it-IT → en-US
  • fr-FR → it-IT, it-IT → fr-FR

Requirements:

  • guid must be present and non-empty for every row.
  • guid values must be unique within the file.
  • Each row must contain at least two non-empty language values.
  • Empty cells are allowed, but translations involving that missing language value cannot be enforced for that row.

Need a ready-to-use example?
Download the template for multidirectional glossary.

The zip file includes a CSV template and an instructions.txt file explaining the template structure.

Multidirectional TBX

Multidirectional glossaries can also be uploaded in TBX v3 (TermBase eXchange, ISO 30042:2019) formatted as UTF-8 with a .tbx extension.
Dialect & Style Support:

  • Only TBX-Basic in DCA style is supported.
  • The root element must declare type="TBX-Basic" and style="dca".
  • Data categories must use and
  • Legacy TBX v2 files (using root elements) are not supported and will be rejected.

Structure & Identifiers:

  • Every
  • Every
  • Empty or

Example TBX Structure:

<?xml version="1.0" encoding="UTF-8"?>
<tbx type="TBX-Basic" style="dca" xml:lang="en-US" xmlns="urn:iso:std:iso:30042:ed-2">
  <tbxHeader>
    <fileDesc>
      <sourceDesc><p>Lara multidirectional glossary template</p></sourceDesc>
    </fileDesc>
  </tbxHeader>
  <text>
    <body>
      <conceptEntry id="g_1">
        <langSec xml:lang="en-US">
          <termSec><term>Settings</term></termSec>
        </langSec>
        <langSec xml:lang="fr-FR">
          <termSec><term>Paramètres</term></termSec>
        </langSec>
        <langSec xml:lang="it-IT">
          <termSec><term>Impostazioni</term></termSec>
        </langSec>
      </conceptEntry>
    </body>
  </text>
</tbx>

Below are examples showing how to import both monodirectional and multidirectional glossaries.

# Import a local csv file to an existing glossary
# Import a unidirectional CSV file (default)
import_job = lara.glossaries.glossary_import('gls_1...', 'path/to/file.csv')

# Import a multidirectional CSV file
import_job = lara.glossaries.glossary_import('gls_1...', 'path/to/file.csv', content_type='csv/table-multi')

# Import a local TBX file to an existing glossary
import_job = lara.glossaries.glossary_import('gls_1...', 'path/to/file.tbx', content_type='tbx')
/*
	NODE
*/
import * as fs from 'fs';

// Import a local CSV file to an existing glossary
// Import unidirectional CSV
const streamCsv = fs.createReadStream('path/to/csv');
const importJobCsv = await lara.glossaries.GlossaryImport('gls_1...', streamCsv, 'csv/table-uni');

// Import multidirectional CSV
const importJobCsvMulti = await lara.glossaries.GlossaryImport('gls_1...', streamCsv, 'csv/table-multi');

// Import a local compressed CSV file to an existing glossary
const streamGzip = fs.createReadStream('path/to/csv.gz');
const importJobGzip = await lara.glossaries.GlossaryImport('gls_1...', streamGzip, true);

// Import a local TBX file to an existing glossary
// Import unidirectional TBX
const streamTbx = fs.createReadStream('path/to/tbx');
const importJobTbx = await lara.glossaries.GlossaryImport('gls_1...', streamTbx, 'tbx/table-uni');

// Import multidirectional TBX
const importJobTbxMulti = await lara.glossaries.GlossaryImport('gls_1...', streamTbx, 'tbx/table-multi');

/*
	BROWSER
*/
// replace with your input id
const fileInput = document.getElementById("fileInput");
const file = fileInput.files[0];

// Import unidirectional CSV
const importJob = await lara.glossaries.GlossaryImport('gls_1...', file, 'csv/table-uni', false);

// Import multidirectional CSV
const importJobMulti = await lara.glossaries.GlossaryImport('gls_1...', file, 'csv/table-multi', false);

// Import compressed CSV (gzip=true)
const importJobGzip = await lara.glossaries.GlossaryImport('gls_1...', file, 'csv/table-uni', true);

// Import unidirectional TBX
const importJobTbx = await lara.glossaries.GlossaryImport('gls_1...', file, 'tbx/table-uni', false);

// Import multidirectional TBX
const importJobTbxMulti = await lara.glossaries.GlossaryImport('gls_1...', file, 'tbx/table-multi', false);
// Import a local csv file to an existing glossary
// Import unidirectional CSV (default)
GlossaryImport importJob = lara.glossaries.glossaryImport("gls_1...", new File("path/to/file.csv"));

// Import multidirectional CSV
GlossaryImport importJobMulti = lara.glossaries.glossaryImport("gls_1...", new File("path/to/file.csv"), Glossary.Type.CSV_TABLE_MULTI);

// Import compressed CSV
GlossaryImport importJobGzip = lara.glossaries.glossaryImport("gls_1...", new File("path/to/file.csv.gz"), Glossary.Type.CSV_TABLE_UNI, true);

// Import a local tbx file to an existing glossary
// Import unidirectional TBX
GlossaryImport importJobTbx = lara.glossaries.glossaryImport("gls_1...", new File("path/to/file.tbx"), Glossary.Type.TBX_TABLE_UNI);

// Import multidirectional TBX
GlossaryImport importJobTbxMulti = lara.glossaries.glossaryImport("gls_1...", new File("path/to/file.tbx"), Glossary.Type.TBX_TABLE_MULTI);
// Import a local csv file to an existing glossary
// Import unidirectional CSV (default)
$importJob = $lara->glossaries->glossaryImport('gls_1...', $csvFilePath);

// Import multidirectional CSV
$importJobMulti = $lara->glossaries->glossaryImport('gls_1...', $csvFilePath, GlossaryFileFormat::CSV_TABLE_MULTI);

// Import compressed CSV
$importJobGzip = $lara->glossaries->glossaryImport('gls_1...', $csvFilePath, true);

// Import a local tbx file to an existing glossary
// Import unidirectional TBX
$importJobTbx = $lara->glossaries->glossaryImport('gls_1...', $tbxFilePath, GlossaryFileFormat::TBX_TABLE_UNI);

// Import multidirectional TBX
$importJobTbxMulti = $lara->glossaries->glossaryImport('gls_1...', $tbxFilePath, GlossaryFileFormat::TBX_TABLE_MULTI);
// Import a local csv file to an existing glossary
// Import unidirectional CSV (default)
importJob, err := lara.Glossaries.ImportCsvFromPath("gls_1...", "path/to/file.csv")

// Import multidirectional CSV
importJob, err := lara.Glossaries.ImportCsvFromPathWithFormat("gls_1...", "path/to/file.csv", lara.GlossaryFileFormatCsvTableMulti)

// Import from file handle (auto-detects gzip from .gz extension)
file, _ := os.Open("path/to/file.csv")
importJob, err := lara.Glossaries.ImportCsvWithFormat("gls_1...", file, lara.GlossaryFileFormatCsvTableUni)

// Import a local tbx file to an existing glossary
// Import unidirectional TBX
importJobTbx, err := lara.Glossaries.ImportTbxFromPath("gls_1...", "path/to/file.tbx")

// Import multidirectional TBX
importJobTbxMulti, err := lara.Glossaries.ImportTbxFromPathWithFormat("gls_1...", "path/to/file.tbx", lara.GlossaryFileFormatTbxTableMulti)
// Import a local CSV file to an existing glossary
// Import unidirectional CSV (default)
val importJob = lara.glossaries.glossaryImport("gls_1...", File("path/to/file.csv"))

// Import multidirectional CSV
val importJobMulti = lara.glossaries.glossaryImport("gls_1...", File("path/to/file.csv"), Glossary.Type.CSV_TABLE_MULTI)

// Import compressed CSV
val importJobGzip = lara.glossaries.glossaryImport("gls_1...", File("path/to/file.csv.gz"), Glossary.Type.CSV_TABLE_UNI, true)

// Import a local TBX file to an existing glossary
// Import unidirectional TBX
val importJobTbx = lara.glossaries.glossaryImport("gls_1...", File("path/to/file.tbx"), Glossary.Type.TBX_TABLE_UNI)

// Import multidirectional TBX
val importJobTbxMulti = lara.glossaries.glossaryImport("gls_1...", File("path/to/file.tbx"), Glossary.Type.TBX_TABLE_MULTI)
// Import a local CSV file to an existing glossary
// Import unidirectional CSV (default)
var importJob = await lara.Glossaries.glossaryImport("gls_1...", "path/to/file.csv");

// Import multidirectional CSV
var importJobMulti = await lara.Glossaries.glossaryImport("gls_1...", "path/to/file.csv", GlossaryType.CsvTableMulti);

// Import a local TBX file to an existing glossary
// Import unidirectional TBX
var importJobTbx = await lara.Glossaries.glossaryImport("gls_1...", "path/to/file.tbx", GlossaryType.TbxTableUni);

// Import multidirectional TBX
var importJobTbxMulti = await lara.Glossaries.glossaryImport("gls_1...", "path/to/file.tbx", GlossaryType.TbxTableMulti);
// Import a local CSV file to an existing glossary
let csvURL = URL(fileURLWithPath: "path/to/file.csv")
let csvData = try Data(contentsOf: csvURL)

// Import unidirectional CSV (default)
let importJob = try await lara.glossaries.glossaryImport(id: "gls_1...", csv: csvData)

// Import multidirectional CSV
let importJobMulti = try await lara.glossaries.glossaryImport(id: "gls_1...", csv: csvData, contentType: .csvTableMulti)

// Import compressed CSV
let importJobGzip = try await lara.glossaries.glossaryImport(id: "gls_1...", csv: csvData, contentType: .csvTableUni, gzip: true)

// Import a local TBX file to an existing glossary
let tbxURL = URL(fileURLWithPath: "path/to/file.tbx")
let tbxData = try Data(contentsOf: tbxURL)

// Import unidirectional TBX
let importJobTbx = try await lara.glossaries.glossaryImport(id: "gls_1...", tbx: tbxData, contentType: .tbxTableUni)

// Import multidirectional TBX
let importJobTbxMulti = try await lara.glossaries.glossaryImport(id: "gls_1...", tbx: tbxData, contentType: .tbxTableMulti)
FieldTypeRequiredDefaultDescription
idStringYes
The unique identifier of the glossary to update. Format: gls_xyz123
fileFile | Stream | StringYes
The file to upload
contentTypeStringNocsv/table-uni

CSV format: csv/table-uni (unidirectional), csv/table-multi (multidirectional)

TBX format: tbx/table-uni (unidirectional), tbx/table-multi (multidirectional)

gzipBooleanNoFalseIndicates if the file is a compressed .gz file. Not present for Python and Java, where it is automatically detected.

Check Import Status

Checks the status of an ongoing glossary import using the unique import_job id returned in the “Import CSV” method

# Check the status of an import job
import_job = lara.glossaries.get_import_status('imp_1...')
// Check the status of an import job
const importJob = await lara.glossaries.getImportStatus('imp_1...');
// Check the status of an import job
GlossaryImport importJob = lara.glossaries.getImportStatus("gls_1...");
// Check the status of an import job
$importJob = $lara->glossaries->getImportStatus('gls_1...');
// Check the status of an import job
importJob, _ := lara.Glossaries.GetImportStatus("imp_1...")
// Check the status of an import job
val importJob: GlossaryImport = lara.glossaries.getImportStatus("gls_1...")
// Check the status of an import job
var importJob = await lara.Glossaries.GetImportStatus("imp_1...");
// Check the status of an import job
let importJob = try await lara.glossaries.getImportStatus(id: "imp_1...")
FieldTypeRequiredDefaultDescription
idStringYes
The ID of the import job

The import status is an object containing:

FieldTypeDescription
idStringThe ID of the import job
progressNumberThe current status of the import job. If it is = 1, it means the import is complete. If < 1, it means the import is still in progress.

Get counts

The counts object gives information about the content of a glossary.

FieldTypeDescription
unidirectionalRecord<string, number>The object is a field for each source language of the glossary, and its value represents the number of elements defined for that language
# Get the counts for a glossary
counts = lara.glossaries.counts('gls_1...')
// Get the counts for a glossary
const counts = await lara.glossaries.counts('gls_1...');
// Get the counts for a glossary
GlossaryCounts counts = lara.glossaries.counts("gls_1...");
// Get the counts for a glossary
$counts = $lara->glossaries->counts("gls_1...");
// Get the counts for a glossary
counts, _ := lara.Glossaries.Counts("gls_1...")
// Get the counts for a glossary
val counts: GlossaryCounts = lara.glossaries.counts("gls_1...")
// Get the counts for a glossary
var counts = await lara.Glossaries.Counts("gls_1...");
// Get the counts for a glossary
let counts = try await lara.glossaries.counts(id: "gls_1...")
FieldTypeRequiredDefaultDescription
idStringYes
The ID of the glossary Format: gls_xyz123

Export glossary

You can export a glossary as a CSV file, formatted according to the Lara CSV Glossary Format.

# Export unidirectional (source required)
csv_data = lara.glossaries.export('gls_1...', content_type='csv/table-uni', source='en-US')

# Export multidirectional
csv_data = lara.glossaries.export('gls_1...', content_type='csv/table-multi')
// Export unidirectional (source required)
const csvData = await lara.glossaries.export('gls_1...', 'csv/table-uni', 'en-US');

// Export multidirectional
const csvDataMulti = await lara.glossaries.export('gls_1...', 'csv/table-multi');
// Export unidirectional (source required)
String csvData = lara.glossaries.export("gls_1...", Glossary.Type.CSV_TABLE_UNI, "en-US");

// Export multidirectional
String csvDataMulti = lara.glossaries.export("gls_1...", Glossary.Type.CSV_TABLE_MULTI);
// Export unidirectional (source required)
$csvData = $lara->glossaries->export('gls_1...', GlossaryFileFormat::CSV_TABLE_UNI, 'en-US');

// Export multidirectional
$csvDataMulti = $lara->glossaries->export('gls_1...', GlossaryFileFormat::CSV_TABLE_MULTI);
// Export unidirectional (source required)
csvData, err := lara.Glossaries.Export("gls_1...", lara.GlossaryFileFormatCsvTableUni, ptr("en-US"))

// Export multidirectional
csvData, err := lara.Glossaries.Export("gls_1...", lara.GlossaryFileFormatCsvTableMulti, nil)
// Export unidirectional (source required)
val csvData = lara.glossaries.export("gls_1...", Glossary.Type.CSV_TABLE_UNI, "en-US")

// Export multidirectional
val csvDataMulti = lara.glossaries.export("gls_1...", Glossary.Type.CSV_TABLE_MULTI)
// Export a glossary
var glossaryContent = await lara.Glossaries.Export("gls_1...", "csv/table-uni", "en-US");
// Export unidirectional (source required)
let csvData = try await lara.glossaries.export(id: "gls_1...", format: .csvTableUni, source: "en-US")

// Export multidirectional
let csvDataMulti = try await lara.glossaries.export(id: "gls_1...", format: .csvTableMulti)
FieldTypeRequiredDefaultDescription
idStringYes
The ID of the glossary Format: gls_xyz123
contentTypeStringYes
  • cvs/table-uni to extract mono-directional entries with the specified source language.
  • cvs/table-multi to extract multi-directional entries.
sourceStringYes (for unidirectional glossaries)
The source language of the glossary

Availability of Glossaries in SDKs

Starting from the following SDK versions, the Glossary feature is available:

  • Python: v1.4.0
  • Node.js (TypeScript/JavaScript): v1.6.0
  • Java: v1.4.0
  • PHP: v1.2.0
  • Go: 1.0.0
  • .NET: 1.0.0
  • Swift: v1.0.0

For more details on implementation, refer to the SDK-specific documentation.

Updated about 16 hours ago

Did this page help you?