Translate Text

Lara is designed to support different translation workflows, from quick daily translations to more advanced use cases that are sensitive to quality and style. Depending on your needs, you can choose how to generate the translation and whether to apply an additional editorial refinement step before receiving the final result.

You can choose between two generation modes - Lara Standard and Lara Think - and optionally apply Lara Prosa as a post-processing step to further refine the final result:

Lara Standard is the default mode. It provides fast and accurate translations with full support for customization features: glossaries, translation memories, instructions, style options, and contextual translation.

Lara Think adds a reasoning phase that deepens the linguistic analysis of all project resources, improving terminological consistency, stylistic accuracy, and overall quality. It requires more computation, so it is recommended when quality takes precedence over latency.

Lara Prosa is applied in post-processing, after Standard or Think. It refines the output according to a style guide, preserving meaning, terminology, and consistency. It is the right choice when the final text must respect a brand voice, an authorial style, or a specific editorial standard.

Translate

To begin, you must first instantiate the Translator class. This is the mandatory first step for all operations within the Lara SDK.

Initialization Guide →

Translates text from a source language to a target language. It supports single-sentence translations, context-aware translations and adaptation to specific translation memories.

Request

res = lara.translate('Hello, how are you?',
    source='en-US',
    target='it-IT',
    profanitiesDetect: "source_target",
    profanitiesHandling: "detect",
    adapt_to=['mem_1_id', 'mem_2_id'],
    glossaries=['gls_1_id', 'gls_2_id'],
    instructions=['Be formal'],
    style="fluid",
    content_type='text/plain',
    timeout_ms=2000,
    priority=TranslatePriority.NORMAL,
    )

print(res.translation)

const res  = await lara.translate('Hello, how are you?', 'en-US', 'it-IT', {
        adaptTo: ['mem_1_id', 'mem_2_id'],
        glossaries: ['gls_1_id', 'gls_2_id'],
        instructions: ['Be formal'],
        profanitiesDetect: "source_target",
        profanitiesHandling: "detect",
        style: 'fluid',
        contentType: 'text/plain',
        timeoutInMillis: 2000,
        priority: 'normal'
});

// All options are optional and can be omitted
TranslateOptions options = new TranslateOptions();
options.setAdaptTo("mem_1_id", "mem_2_id");
options.setGlossaries("gls_1_id", "gls_2_id");
options.setInstructions("Be formal");
options.setProfanitiesDetect(ProfanitiesDetect.SOURCE_TARGET)
options.setProfanitiesHandling(ProfanitiesHandling.DETECT);
options.setStyle(TranslationStyle.FLUID);
options.setContentType("text/plain");
options.setTimeoutMs(2000);
options.setPriority(TranslateOptions.Priority.NORMAL);

TextResult res = lara.translate("Hello, how are you?", "en-US", "it-IT", options);

$options = new TranslateOptions([
    'adaptTo' => array('mem_1_id', 'mem_2_id'),
     'glossaries' => array('gls_1_id', 'gls_2_id'),
    'instructions' => array('Be formal'),
	  'style' => 'fluid',
    'contentType' => 'text/plain',
    'timeoutInMillis' => 2000,
    'priority' => 'normal'
]);

$res = $lara->translate('Hello, how are you?', 'en-US', 'it-IT', $options);

res, _ := lara.Translate("Hello, how are you?", "en-US", "it-IT",
	lara_sdk.TranslateOptions{
		Instructions: []string{"Be formal"},
		Style:        "fluid",
		ContentType:  "text/plain",
		TimeoutMs:    2000,
		Priority:     "normal"
  })

fmt.Println(*res.Translation.String)

// All options are optional and can be omitted
val options = TranslateOptions().apply {
    setAdaptTo("mem_1_id", "mem_2_id")
    setGlossaries("gls_1_id", "gls_2_id")
    setInstructions("Be formal")
    setStyle(TranslationStyle.FLUID)
    setContentType("text/plain")
    setTimeoutMs(2000)
    setPriority(TranslateOptions.Priority.NORMAL)
    setUseCache(TranslateOptions.UseCache.YES)
    setCacheTTL(86400)
}

val res: TextResult = lara.translate(
    "Hello, how are you?",
    "en-US",
    "it-IT",
    options
)

var res = await lara.Translate(
    "test example", "en-US", "it-IT",
new TranslateOptions {
    Instructions = new[] { "Be formal" },
    Style = TranslationStyle.Fluid,
    ContentType = "text/plain",
    TimeoutInMillis = 2000,
    Priority = TranslatePriority.Normal,
});

// All options are optional and can be omitted
let options = TranslateOptions()
    .setAdaptTo(["mem_1_id", "mem_2_id"])
    .setGlossaries(["gls_1_id", "gls_2_id"])
    .setInstructions(["Be formal"])
    .setStyle(.fluid)
    .setContentType("text/plain")
    .setTimeoutMs(2000)
    .setPriority(.normal)

let res = try await lara.translate(text: "Hello, how are you?", source: "en-US", target: "it-IT", options: options)

Here follows the basic fields for the translate method:

Field	Type	Required	Default	Description
text	String \| String[] \| TextBlock[]	Yes		The text to be translated. This can be a single string or a list (up to 128 elements) of strings or `TextBlock` objects for incremental translation. Use `String[]`or`TextBlock`strictly for context-linked strings, not for batch translating unrelated texts.
source	String	No	Autodetected	The source language code (e.g., "en-US" for English). If not specified, the system will attempt to detect it automatically.
target	String	Yes		The target language code (e.g., "it-IT" for Italian). This specifies the language you want the text translated into.

Several options are available to customize the behavior of the translate method:

Field	Type	Required	Default	Description
source_hint	String	No		Used to guide language detection. Specify this when the source language is uncertain to improve detection accuracy.
adapt_to	String[]	No	Default is all Memories on your account	A list of translation memory IDs for adapting the translation.
glossaries	String[]	No		A list of glossary IDs.
instructions	String[]	No	[ ]	A list of instructions to adjust the network’s behavior regarding the output (e.g., "Use a formal tone"). If you plan to use instructions please carefully read here
reasoning	Boolean	No	False	Reasoning engine that improves translation quality
styleguideId	Integer	No		The ID of the style guide that will be used by Lara Prosa
styleguideReasoning	Boolean	No	False	If set to `true`, Lara Prosa will be active in reasoning mode
styleguideExplanationLanguage	String	No	en	The language of the comments regarding the changes to the translation by Lara Prosa
profanitiesDetect	String	No		defines the scope of the profanity filtering. Available options: `source_target` `target`
profanitiesHandling	String	No	`hide`	Specifies how Lara handles profanity in the translation. Available options: `detect` `hide` `avoid`
style	String	No	`faithful`	The style to apply to the translation. Available values: `faithful` `fluid` `creative`
content_type	String	No	Autodetected	Specifies the `Content-Type` of the text. Available values: `text/plain` `text/html` `application/xliff+xml`
timeout_ms	Integer	No	None	Specifies the maximum allowable time (in milliseconds) to perform the translation. If the timeout is exceeded, a `TimeoutException` is raised.
priority	String	No	Normal	Specifies whether the translation should be executed as a normal priority task or can wait for other tasks to complete.
use_cache	Boolean	No	False	Specifies whether the translation should be saved in the cache for future retrieval. Note: Caching is an advanced feature and is not enabled by default. To enable caching for your account, please contact our sales team .
cache_ttl	Integer	No	2 Years	The time-to-live (TTL) for the cache entry, specifying how long the translation will remain in the cache.
verbose	Boolean	No	False	When enabled, this parameter returns additional debugging and metadata information from the engine, such as memory and glossary matches. Not recommended for production use, as it can significantly impact response times.
headers	List[String, String]	No	None	An optional object containing additional HTTP headers to include in the request. This field is primarily intended for debugging purposes and future extensibility. Use with caution. Custom headers are not required for standard usage and may be ignored or restricted by the server.
no_trace (see the snippet below for the correct syntax)	Boolean	No	False	If set to True, source content and its translation will not be saved on our system. (AKA Incognito mode)

Incognito mode

res = lara.translate('Hello, how are you?',
    source='en-US',
    target='it-IT',
   	noTrace = true
    )

print(res.translation)

const res  = await lara.translate('Hello, how are you?', 'en-US', 'it-IT', {
        adaptTo: ['mem_1_id', 'mem_2_id'],
        glossaries: ['gls_1_id', 'gls_2_id'],
        no_trace: true
});

// All options are optional and can be omitted
TranslateOptions options = new TranslateOptions();
options.setAdaptTo("mem_1_id", "mem_2_id");
options.setGlossaries("gls_1_id", "gls_2_id");
options.setNoTrace(true);

TextResult res = lara.translate("Hello, how are you?", "en-US", "it-IT", options);

$options = new TranslateOptions([
    'adaptTo' => array('mem_1_id', 'mem_2_id'),
     'glossaries' => array('gls_1_id', 'gls_2_id'),
	  'noTrace' => true,
]);

$res = $lara->translate('Hello, how are you?', 'en-US', 'it-IT', $options);

res, _ := lara.Translate("Hello, how are you?", "en-US", "it-IT",
	lara_sdk.TranslateOptions{
		Instructions: []string{"Be formal"},
		Style:        "fluid",
		ContentType:  "text/plain",
		NoTrace:    true
  })

fmt.Println(*res.Translation.String)

// All options are optional and can be omitted
val options = TranslateOptions().apply {
    setAdaptTo("mem_1_id", "mem_2_id")
    setGlossaries("gls_1_id", "gls_2_id")
    setInstructions("Be formal")
    setNoTrace(true)
}

val res: TextResult = lara.translate(
    "Hello, how are you?",
    "en-US",
    "it-IT",
    options
)

var res = await lara.Translate(
    "test example", "en-US", "it-IT",
new TranslateOptions {
    Instructions = new[] { "Be formal" },
    Style = TranslationStyle.Fluid,
    NoTrace = true
});

// All options are optional and can be omitted
let options = TranslateOptions()
    .setAdaptTo(["mem_1_id", "mem_2_id"])
    .setGlossaries(["gls_1_id", "gls_2_id"])
    .setInstructions(["Be formal"])
    .setNoTrace(true)
    

let res = try await lara.translate(text: "Hello, how are you?", source: "en-US", target: "it-IT", options: options)

Response

# Single string
TextResult(
    content_type="text/plain",
    source_language="en",
    adapted_to=["mem_1_id", "mem_2_id"],
    translation="Ciao, come stai?"
)

# String array
TextResult(
    content_type="text/plain",
    source_language="en",
    adapted_to=["mem_1_id", "mem_2_id"],
    translation=['Ciao, come stai?', 'Che giornata meravigliosa.']
)

# TextBlock array
TextResult(
    content_type="text/plain",
    source_language="en",
    adapted_to=["mem_1_id", "mem_2_id"],
    translation=[
        TextBlock(text="Ciao, come stai?", translatable=True),
        TextBlock(text="Che giornata meravigliosa.", translatable=True)
    ]
)

// Single string
{
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: 'Salve, come sta?',
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// String array
{
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: ['Salve, come sta?', 'Che bella giornata.'],
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// TextBlock array
{
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: [
      { text: 'Salve, come sta?', translatable: true },
      { text: 'Che bella giornata.', translatable: true }
    ],
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// Single string
TextResult(
    contentType="text/plain",
    sourceLanguage="en",
    adaptedTo=["mem_1_id", "mem_2_id"],
    translation="Ciao, come stai?"
)

// String array
TextResult(
    contentType="text/plain",
    sourceLanguage="en",
    adaptedTo=["mem_1_id", "mem_2_id"],
    translation=['Ciao, come stai?', 'Che giornata meravigliosa.']
)

// TextBlock array
TextResult(
    contentType="text/plain",
    sourceLanguage="en",
    adaptedTo=["mem_1_id", "mem_2_id"],
    translation=[
        TextBlock(text="Ciao, come stai?", translatable=true),
        TextBlock(text="Che giornata meravigliosa.", translatable=true)
    ]
)

// Single string
Lara\TextResult {
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: 'Salve, come sta?',
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// String array
Lara\TextResult {
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: ['Salve, come sta?', 'Che bella giornata.'],
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// TextBlock array
Lara\TextResult {
    contentType: 'text/plain',
    sourceLanguage: 'en-US',
    translation: [
        Lara\TextBlock { text: 'Salve, come sta?', translatable: true },
        Lara\TextBlock { text: 'Che bella giornata.', translatable: true }
    ],
    adaptedTo: [ 'mem_1_id', 'mem_2_id']
}

// Single string
TextResult{
    ContentType:    "text/plain",
    SourceLanguage: "en-US",
    Translation: Translation{
        String: &"Salve, come sta?",
    },
    AdaptedTo: []string{"mem_1_id", "mem_2_id"},
}

// String array
TextResult{
    ContentType:    "text/plain",
    SourceLanguage: "en-US",
    Translation: Translation{
        Strings: []string{"Salve, come sta?", "Che bella giornata."},
    },
    AdaptedTo: []string{"mem_1_id", "mem_2_id"},
}

// TextBlock array
TextResult{
    ContentType:    "text/plain",
    SourceLanguage: "en-US",
    Translation: Translation{
        TextBlocks: []TextBlock{
            {Text: "Salve, come sta?", Translatable: true},
            {Text: "Che bella giornata.", Translatable: true},
        },
    },
    AdaptedTo: []string{"mem_1_id", "mem_2_id"},
}

// Single string
val single = TextResult(
    contentType = "text/plain",
    sourceLanguage = "en",
    adaptedTo = listOf("mem_1_id", "mem_2_id"),
    translation = "Ciao, come stai?"
)

// String array
val multipleStrings = TextResult(
    contentType = "text/plain",
    sourceLanguage = "en",
    adaptedTo = listOf("mem_1_id", "mem_2_id"),
    translation = listOf("Ciao, come stai?", "Che giornata meravigliosa.")
)

// TextBlock array
val textBlocks = TextResult(
    contentType = "text/plain",
    sourceLanguage = "en",
    adaptedTo = listOf("mem_1_id", "mem_2_id"),
    translation = listOf(
        TextBlock(text = "Ciao, come stai?", translatable = true),
        TextBlock(text = "Che giornata meravigliosa.", translatable = true)
    )
)

// Single string
TextResult(
    ContentType = "text/plain",
    SourceLanguage = "en",
    AdaptedTo = new List<string> { "mem_1_id", "mem_2_id" },
    Translation = "Ciao, come stai?"
)

// String array
TextResult(
    ContentType = "text/plain",
    SourceLanguage = "en",
    AdaptedTo = new List<string> { "mem_1_id", "mem_2_id" },
    Translation = new List<string> { "Ciao, come stai?", "Che giornata meravigliosa." }
)

// TextBlock array
TextResult(
    ContentType = "text/plain",
    SourceLanguage = "en",
    AdaptedTo = new List<string> { "mem_1_id", "mem_2_id" },
    Translation = new List<TextBlock> {
        new TextBlock("Ciao, come stai?", true),
        new TextBlock("Che giornata meravigliosa.", true)
    }
)

// Single string
TextResult(
    contentType: "text/plain",
    sourceLanguage: "en",
    translation: TranslatedValue(translation: "Ciao, come stai?"),
    adaptedTo: ["mem_1_id", "mem_2_id"]
)

// String array
TextResult(
    contentType: "text/plain",
    sourceLanguage: "en", 
    translation: TranslatedValue(translations: ["Ciao, come stai?", "Che giornata meravigliosa."]),
    adaptedTo: ["mem_1_id", "mem_2_id"]
)

// TextBlock array
TextResult(
    contentType: "text/plain",
    sourceLanguage: "en",
    translation: TranslatedValue(translationBlocks: [
        TextBlock(text: "Ciao, come stai?", translatable: true),
        TextBlock(text: "Che giornata meravigliosa.", translatable: true)
    ]),
    adaptedTo: ["mem_1_id", "mem_2_id"]
)

❗️
XLIFF support
Support for the application/xliff+xml content type is limited to text and a specific set of inline tags within the <source> element:
XLIFF 1.2:<g>, <x>, <ex>, <bx>, <ph>, <it>, and <mrk>.
XLIFF 2.0: <cp>, <ph>, <pc>, <sc>, <ec>, <sm>, <em> and <mrk>.
For all other tags or advanced XLIFF features, please use the Document Translation service.

Lara Prosa

Lara Prosa is an advanced stylistic translation service for high-value content where voice, rhythm, and editorial quality matter as much as accuracy.

It builds on Lara’s core translation capabilities by combining glossaries, translation memories, and style guides to preserve meaning, terminology, consistency, and authorial or brand voice.

Rather than producing only fluent translations, Lara Prosa refines the text to maintain the distinctive nuances, personality, and expressive choices of the original. Alongside the translated output, it also provides structured editorial notes that explain key stylistic decisions.

Lara Prosa is designed for literary content, author-driven material, premium editorial workflows, and brand-sensitive communication where stylistic fidelity is essential.

Availability & Pricing

Lara Prosa is available on the plans below. Pricing is calculated per one million source characters.

Plan	Standard	With reasoning
Free	Not Available	Not Available
Pro	€ 200*	€ 400*
Team	€ 150*	€ 300*

*Pricing per 1M characters

To use Lara Prosa, simply pass the styleguideId parameter with the ID of the style guide you want to use. If you want higher quality, you can activate the styleguideReasoning:true parameter.

res = lara.translate('Hello, how are you?',
                     source='en-US',
                     target='it-IT',
                     styleguideId=123456,
                     styleguideReasoning=True
                     )

print(res.translation)

const res  = await lara.translate('Hello, how are you?', 'en-US', 'it-IT', {
        styleguideReasoning: true,
        styleguideId=123456
});

TranslateOptions options = new TranslateOptions();
options.setStyle(TranslationStyle.FLUID);
options.setReasoning(true);

TextResult res = lara.translate("Hello, how are you?", "en-US", "it-IT", options);

$options = new TranslateOptions([
	'styleguideReasoning':true,
  'styleguideId'=123456
]);

$res = $lara->translate('Hello, how are you?', 'en-US', 'it-IT', $options);

res, _ := lara.Translate("Hello, how are you?", "en-US", "it-IT",
	lara_sdk.TranslateOptions{
		StyleguideReasoning:  true,
		StyleguideId:    123456
  })

fmt.Println(*res.Translation.String)

// Sdk available soon

var res = await lara.Translate(
    "test example", "en-US", "it-IT",
new TranslateOptions {
  	styleguideReasoning = true,
		styleguideId = 123456,
});

// All options are optional and can be omitted
let options = TranslateOptions()
    .setAdaptTo(["mem_1_id", "mem_2_id"])
    .setStyleguideId(123456)
		.setStyleguideReasoning(true)
	  
let res = try await lara.translate(text: "Hello, how are you?", source: "en-US", target: "it-IT", options: options)

📘
Create your style guide
Here you can find all the information you need to create and manage your style guides

Lara Think

Lara Think is an advanced AI translation model that performs multi-step linguistic analysis across all available project assets, including glossaries, style guides, and contextual metadata.

This approach enables automatic detection and correction of approximately 80% of major linguistic issues, improving terminology consistency and stylistic accuracy compared to standard models.

Lara Think requires significantly more computation and can result in up to a 10× increase in processing time. It is best suited for workflows where translation quality and consistency are prioritized over latency.

Availability & Pricing

As a result of its higher computational cost, Lara Think is available on the plans below. Pricing is calculated per one million source characters.

Plan	Pricing (per 1M characters)
Free	Not Available
Pro	€ 2000
Team	€ 1500

Basic Reasoning Usage

To enable reasoning, simply pass the reasoning:true parameter within the options object. This method returns the final translation after the reasoning process is complete.

res = lara.translate('Hello, how are you?',
                     source='en-US',
                     target='it-IT',
                     style="fluid",
                     reasoning=True,
                     )

print(res.translation)

const res  = await lara.translate('Hello, how are you?', 'en-US', 'it-IT', {
        reasoning: true,
        style: 'fluid',
});

TranslateOptions options = new TranslateOptions();
options.setStyle(TranslationStyle.FLUID);
options.setReasoning(true);

TextResult res = lara.translate("Hello, how are you?", "en-US", "it-IT", options);

$options = new TranslateOptions([
    'reasoning' => true,
    'style' => 'fluid'
]);

$res = $lara->translate('Hello, how are you?', 'en-US', 'it-IT', $options);

// Sdk available soon

// Sdk available soon

var res = await lara.Translate(
    "test example", "en-US", "it-IT",
new TranslateOptions {
     Reasoning = true,
     Style = TranslationStyle.Fluid,
});

// All options are optional and can be omitted
let options = TranslateOptions()
    .setAdaptTo(["mem_1_id", "mem_2_id"])
    .setGlossaries(["gls_1_id", "gls_2_id"])
		.setReasoning(true)
    
let res = try await lara.translate(text: "Hello, how are you?", source: "en-US", target: "it-IT", options: options)

Handling Partial Results

If you want to receive the initial translation (Lara) and subsequently the refined version (Lara Think), you can implement a callback function.

The callback will be triggered as soon as the preliminary results are available, while the await will resolve with the final reasoned translation.

res = lara.translate('Hello, how are you?',
                     source='en-US',
                     target='it-IT',
                     style="fluid",
                     reasoning=True,
                     callback=lambda partial: print("translate reasoning partial:", result),
                     )

print(res.translation)

const res  = await lara.translate('Hello, how are you?', 'en-US', 'it-IT', {
        reasoning:true,
        style: 'fluid',
}, (partialResult) => console.log(partialResult)
);

TranslateOptions options = new TranslateOptions();
options.setStyle(TranslationStyle.FLUID);
options.setReasoning(true);

Consumer<TextResult> onPartial = partial ->
                        System.out.println("translate reasoning partial" + ": " + partial.getTranslation());

TextResult res = lara.translate("Hello, how are you?", "en-US", "it-IT", options, onPartial);

$lara->translate(
    "Please summarize the following: Lara translates text.",
    $source, $target,
    new TranslateOptions([
        'reasoning' => true,
        'style' => 'fluid'
    ]),
    function ($partial) {
        print_r($partial);
    }
);;

// Sdk available soon

val options = TranslateOptions().apply {
    style = TranslationStyle.FLUID
    reasoning = true
}
val onPartial: Consumer<TextResult> = Consumer { partial ->
    println("translate reasoning partial: ${partial.translation}")
}
val res: TextResult = lara.translate("Hello, how are you?", "en-US", "it-IT", options, onPartial)

var result = await lara.Translate<string>(
    "Please summarize the following: Lara translates text.",
    source, target,
    new TranslateOptions
    {
        Reasoning = true,
        Style = TranslationStyle.Fluid,
    },
    partial => Console.WriteLine(partial) 
);

// Sdk available soon

Profanity Filter

The profanity filter option is designed to give you control over the handling of offensive language during the translation process. Instead of simply blocking content, the service allows you to automate the detection and transformation of profanity to ensure that the final result aligns with your safety standards or specific use cases. It bridges the gap between raw translation and content moderation, making it easier to maintain a professional tone in multiple languages.

Parameters

profanitiesDetect: Defines the "where" You can choose to analyze only the generated output (target) if you are only interested in the final result, or to check both the input and the output (source_target) for more comprehensive filtering.
profanitiesHandling: Defines the "what" Determines whether the system should simply flag the terms (detect), mask them with placeholders (hide), or actively attempt to reformulate the translation to provide an appropriate alternative (avoid).

Do Not Translate (DNT tags)

To ensure maximum translation accuracy, Lara supports the exclusion of specific text segments. When the translation engine encounters a DNT tag, the content enclosed within it will be preserved in its entirety, without undergoing any translation, localization, or capitalization changes.

Web Standards (Recommended)

These tags are the standard for the web and ensure maximum compatibility with crawlers and localization systems:

HTML5 attribute (W3C standard):
Use the attribute translate="no" on any HTML tag.
Example:<p translate="no">BrandName</p> or <div translate="no">Confidential text</div>
Legacy CSS class:
Support for the .notranslate class.
Example:<span class="notranslate">text not to be translated</span>

Note: The attribute translate="no" and the class notranslate are recognized on every type of HTML element (e.g. <div>, <p>, <a>, etc.) and are not limited to the <span> tag only.

Custom Tag (XML/HTML)

For specific contexts or custom formats, you can use the dedicated custom tag:

XML/HTML tag: <notranslate> ProductCode123 </notranslate>

⚠️
Important notes
Limitations of the Plain Text format: Please note that this feature is not available when the input content is sent as text/plain. To enable tag recognition, make sure the input format is correctly set to text/html.

Summary Table: It might be useful to add a summary table for developers who need a quick reference:

Syntax	Type	Example
`translate="no"`	W3C Standard	`<span translate="no">`...`</span>`
`class="notranslate"`	Web Legacy	`<div class="notranslate">`...`</div>`
`<notranslate>`	Custom	`<notranslate>`ID_001`</notranslate>`