https://api.modernmt.com/

By default, the documentation demonstrates using cURL to interact with the API over HTTPS. Select one of our official client libraries to see examples in code.

npm i modernmt # or yarn add

# browser
<script src="https://unpkg.com/modernmt"></script>

pip3 install modernmt

go get github.com/modernmt/modernmt-go

# maven
<dependency>
    <groupId>com.modernmt</groupId>
    <artifactId>modernmt-java</artifactId> 
    <version>1.5.0</version>
</dependency>

# gradle
compile "com.modernmt:modernmt-java:1.5.0"

dotnet add package modernmt-dotnet

composer require modernmt/modernmt-php

curl -H "MMT-ApiKey: YOUR_API_KEY" ...

import {ModernMT} from "modernmt";

const mmt = new ModernMT("YOUR_API_KEY")

from modernmt import ModernMT

mmt = ModernMT("YOUR_API_KEY")

import (
    "github.com/modernmt/modernmt-go"
)

mmt := modernmt.Create("YOUR_API_KEY")

import com.modernmt.ModernMT;

ModernMT mmt = new ModernMT("YOUR_API_KEY");

using ModernMT;

var mmt = new ModernMTService("YOUR_API_KEY");

require "./vendor/autoload.php";

use ModernMT\ModernMT;

$mmt = new ModernMT("YOUR_API_KEY");

curl -H "MMT-ApiKey: YOUR_API_KEY" -H "MMT-Platform: simple-cat-tool" -H "MMT-PlatformVersion: 1.2.8" ...

import {ModernMT} from "modernmt";

const mmt = new ModernMT("YOUR_API_KEY", "simple-cat-tool", "1.2.8")

from modernmt import ModernMT

mmt = ModernMT("YOUR_API_KEY", "simple-cat-tool", "1.2.8")

import (
    "github.com/modernmt/modernmt-go"
)

mmt := modernmt.CreateWithIdentity("YOUR_API_KEY", "simple-cat-tool", "1.2.8")

import com.modernmt.ModernMT;

ModernMT mmt = new ModernMT("YOUR_API_KEY", "simple-cat-tool", "1.2.8");

using ModernMT;

var mmt = new ModernMTService("YOUR_API_KEY", "simple-cat-tool", "1.2.8");

require "./vendor/autoload.php";

use ModernMT\ModernMT;

$mmt = new ModernMT("YOUR_API_KEY", "simple-cat-tool", "1.2.8");

{
  "status": 200,
  "data": ...
}

{
  "status": 400,
  "error": {
    "type": "UnsupportedLanguageException",
    "message": "Language pair not supported: en > xd"
  }
}

curl "https://api.modernmt.com/translate/languages"

const languages = await mmt.listSupportedLanguages()

languages = mmt.list_supported_languages()

languages, err := mmt.ListSupportedLanguages()

List<String> languages = mmt.listSupportedLanguages();

var languages = mmt.ListSupportedLanguages();

$languages = $mmt->list_supported_languages();

{
  "data": [...],
  "status": 200
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"q":"buongiorno"}' \
    "https://api.modernmt.com/translate/detect"

const language = await mmt.detectLanguage("buongiorno")

language = mmt.detect_language("buongiorno")

language, err := mmt.DetectLanguage("buongiorno", "")

DetectedLanguage language = mmt.detectLanguage("buongiorno");

var language = mmt.DetectLanguage("buongiorno");

$language = $mmt->detect_language("buongiorno");

{
  "status": 200,
  "data": {
    "detectedLanguage": "it",
    "billedCharacters": 0
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"q":["buongiorno", "goodmorning"]}' \
    "https://api.modernmt.com/translate/detect"

const languages = await mmt.detectLanguage(["buongiorno", "goodmorning"])

languages = mmt.detect_language(["buongiorno", "goodmorning"])

languages, err := mmt.DetectLanguage([]string{"buongiorno", "goodmorning"}, "")

List<DetectedLanguage> languages = mmt.detectLanguage(Arrays.asList("buongiorno", "goodmorning"));

var languages = mmt.DetectLanguage(new List<string>{"buongiorno", "goodmorning"});

$languages = $mmt->detect_language(["buongiorno", "goodmorning"]);

{
  "status": 200,
  "data": [
    {
      "detectedLanguage": "it",
      "billedCharacters": 0
    },
    {
      "detectedLanguage": "en",
      "billedCharacters": 0
    }
  ]
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source":"en", "target":"it", "q":"Hello world."}' \
    "https://api.modernmt.com/translate"

const translation = await mmt.translate("en", "it", "Hello world.")

translation = mmt.translate("en", "it", "Hello world.")

translation, err := mmt.Translate("en", "it", "Hello world", nil)

Translation translation = mmt.translate("en", "it", "Hello world.");

var translation = mmt.Translate("en", "it", "Hello world.");

$translation = $mmt->translate("en", "it", "Hello world.");

{
  "status": 200,
  "data": {
    "translation": "Ciao mondo.",
    "billedCharacters": 12,
    "characters": 12
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "en", "target":"it", "q":["Hello world.", "This is a test"]}' \
    "https://api.modernmt.com/translate"

const translations = await mmt.translate("en", "it", ["Hello world.", "This is a test"])

translations = mmt.translate("en", "it", ["Hello world.", "This is a test"])

translations, err := mmt.TranslateList("en", "it", []string{"Hello world.", "This is a test"}, nil)

List<Translation> translations = mmt.translate("en", "it", Arrays.asList("Hello world.", "This is a test"));

var translations = mmt.Translate("en", "it", new List<string>{"Hello world.", "This is a test"});

$translations = $mmt->translate("en", "it", ["Hello world.", "This is a test"]);

{
  "status": 200,
  "data": [
    {
      "translation": "Ciao mondo.",
      "billedCharacters": 12,
      "characters": 12
    },
    {
      "translation": "Questo è un test",
      "billedCharacters": 14,
      "characters": 14
    }
  ]
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "it", "target":"en", "q":"Dì il mio nome.", "hints":"37790"}' \
    "https://api.modernmt.com/translate"

const translation = await mmt.translate("it", "en", "Dì il mio nome.", [37790])

translation = mmt.translate("it", "en", "Dì il mio nome.", [37790])

translation, err := mmt.TranslateAdaptive("it", "en", "Dì il mio nome.", []int64{37790}, "", nil)

Translation translation = mmt.translate("it", "en", "Dì il mio nome.", new long[]{37790});

var translation = mmt.Translate("it", "en", "Dì il mio nome.", new long[]{37790});

$translation = $mmt->translate("it", "en", "Dì il mio nome.", [37790]);

{
  "status": 200,
  "data": {
    "translation": "Say my name.",
    "billedCharacters": 15,
    "characters": 15,
    "contextVector": "37790:1"
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "en", "target":"it", "q":"I loved the movie: The perks of being a wallflower.",
    "glossaries":"37787,37784,37790,37791"}' \
    "https://api.modernmt.com/translate"

const translation = await mmt.translate("en", "it", "I loved the movie: The perks of being a wallflower.", undefined, undefined, {
    glossaries: [37787, 37784, 37790, 37791]
});

translation = mmt.translate("en", "it", "I loved the movie: The perks of being a wallflower.", options={
    "glossaries": [37787, 37784, 37790, 37791],
})

options := modernmt.TranslateOptions{
    Glossaries: []int64{37787, 37784, 37790, 37791},
}
translation, err := mmt.Translate("en", "it", "I loved the movie: The perks of being a wallflower.", &options)

TranslateOptions opts = new TranslateOptions();
opts.setGlossaries(new long[]{ 37787, 37784, 37790, 37791 });

Translation translation = mmt.translate("en", "it", "I loved the movie: The perks of being a wallflower.", opts);

var options = new TranslateOptions();
options.SetGlossaries(new long[] { 37787, 37784, 37790, 37791 });

var translation = mmt.Translate("en", "it", "I loved the movie: The perks of being a wallflower.", options);

$translation = $mmt->translate("en", "it", "I loved the movie: The perks of being a wallflower.", null, null, [
    'glossaries' => [37787, 37784, 37790, 37791],
]);

{
  "status": 200,
  "data": {
    "translation": "Ho adorato il film: Noi siamo infinito.",
    "billedCharacters": 34,
    "characters": 34,
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "en", "target":"it", "q":"The weather is good today", "alt_translations": 2}' \
    "https://api.modernmt.com/translate"

const translation = await mmt.translate("en", "it", "The weather is good today", undefined, undefined, {
    altTranslations: 2
})

translation = mmt.translate("en", "it", "The weather is good today", options={
    "alt_translations": 2
})

translation, err := mmt.Translate("en", "it", "The weather is good today", &modernmt.TranslateOptions{
    AltTranslations: 2,
})

TranslateOptions opts = new TranslateOptions();
opts.setAltTranslations(2);
Translation translation = mmt.translate("en", "it", "The weather is good today", opts);

var translation = mmt.Translate("en", "it", "The weather is good today", new TranslateOptions
{
    AltTranslations = 2
});

$translation = $mmt->translate("en", "it", "The weather is good today", null, null, [
    'alt_translations' => 2
]);

{
  "status": 200,
  "data": {
    "translation": "Il tempo è bello oggi",
    "billedCharacters": 25,
    "characters": 25,
    "altTranslations": [
      "Il tempo è buono oggi",
      "Oggi il tempo è bello"
    ]
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "en", "target":"it", "q":"Fuck you", "mask_profanities": true}' \
    "https://api.modernmt.com/translate"

const translation = await mmt.translate("en", "it", "Fuck you", undefined, undefined, {
    maskProfanities: true
})

translation = mmt.translate("en", "it", "Fuck you", options={
    "mask_profanities": True
})

translation, err := mmt.Translate("en", "it", "Fuck you", &modernmt.TranslateOptions{
    MaskProfanities: true,
})

TranslateOptions opts = new TranslateOptions();
opts.setMaskProfanities(true);
Translation translation = mmt.translate("en", "it", "Fuck you", opts);

var translation = mmt.Translate("en", "it", "Fuck you", new TranslateOptions
{
    MaskProfanities = true
});

$translation = $mmt->translate("en", "it", "Fuck you", null, null, [
    'mask_profanities' => true
]);

{
  "status": 200,
  "data": {
    "translation": "V********o",
    "billedCharacters": 8,
    "characters": 8,
    "detectedProfanities": true
  }
}

curl -X POST \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    -H "x-idempotency-key: b7f04ab3-68d6-47c0-8eea-0743a710b620" \
    --data '{"source":"en", "target":"it", "q":"Hello world.",
    "webhook":"https://example.com", "metadata": {"timestamp":1676023422231}}' \
    "https://api.modernmt.com/translate/batch"

// --- Request ---
const webhook = 'https://example.com';
const enqueued = await mmt.batchTranslate(webhook, 'en', 'it', 'Hello world.', undefined, undefined, {
    metadata: {
        timestamp: Date.now()
    },
    idempotencyKey: 'b7f04ab3-68d6-47c0-8eea-0743a710b620'
})

// --- Callback ---
// body must be an object or a json string
// signature must be the value of 'x-modernmt-signature' header
const batchTranslation = await mmt.handleCallback(body, signature)

# --- Request ---
webhook = 'https://example.com'
enqueued = mmt.batch_translate(webhook, 'en', 'it', 'Hello world.', options={
    'metadata': {
        'timestamp': time.time()
    },
    'idempotency_key': 'b7f04ab3-68d6-47c0-8eea-0743a710b620'
})

# --- Callback ---
# body must be a dictionary or a json string
# signature must be the value of 'x-modernmt-signature' header
data, metadata = mmt.handle_callback(body, signature)

// --- Request ---
options := modernmt.TranslateOptions{
    Metadata: metadata{
        time.Now().UnixNano() / int64(time.Millisecond), // Timestamp
    },
    IdempotencyKey: "b7f04ab3-68d6-47c0-8eea-0743a710b620",
}

webhook := "https://example.com"
enqueued, err := mmt.BatchTranslate(webhook, "en", "it", "Hello world.", &options)

// --- Callback ---
// body must be a slice of bytes
// signature must be the value of 'x-modernmt-signature' header
metadata := &metadata{}
data, err := mmt.HandleTranslateCallbackWithMetadata(body, signature, &metadata)

// --- Request ---
TranslateOptions opts = new TranslateOptions();
opts.setMetadata(new Metadata()); // in our example has a timestamp field
opts.setIdempotencyKey("b7f04ab3-68d6-47c0-8eea-0743a710b620");

String webhook = "https://example.com";
boolean enqueued = mmt.batchTranslate(webhook, "en", "it", "Hello world.", opts);

// --- Callback ---
// body must be an Object or a json string
// signature must be the value of 'x-modernmt-signature' header
// the third parameter is the class of metadata object (if any)
BatchTranslation batchTranslation = mmt.handleCallback(body, signature, Metadata.class);

// --- Request ---
var opts = new TranslateOptions
{
    Metadata = new Dictionary<string, dynamic>
    {
        { "timestamp", DateTimeOffset.Now.ToUnixTimeMilliseconds() }
    },
    IdempotencyKey = "b7f04ab3-68d6-47c0-8eea-0743a710b620"
};

const string webhook = "https://example.com";
var enqueued = mmt.BatchTranslate(webhook, "en", "it", "Hello world.", opts);

// --- Callback ---
// body must be an object or a json string
// signature must be the value of 'x-modernmt-signature' header
BatchTranslation batchTranslation = mmt.HandleCallback(body, signature);

// --- Request ---
$webhook = "https://example.com";
$enqueued = $mmt->batchTranslate($webhook, "en", "it", "Hello world.", null, null, [
    "metadata" => [
        "timestamp" => floor(microtime(true) * 1000)
    ],
    "idempotency_key" => "b7f04ab3-68d6-47c0-8eea-0743a710b620"
]);

// --- Callback ---
// body must be an associative array or a json string
// signature must be the value of 'x-modernmt-signature' header
$batchTranslation = $mmt->handleCallback($body, $signature);

{
  "status": 200,
  "data": {
    "enqueued": true
  }
}

{
  "result": {
    "status": 200,
    "data": {
      "translation": "Ciao mondo.",
      "billedCharacters": 12,
      "characters": 12,
    }
  },
  "metadata": {
    "timestamp": 1676023422231
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source":"en", "target":"it",
    "sentence":"Hello world", "translation": "Ciao mondo"}' \
    "https://api.modernmt.com/translate/qe"

const qe = await mmt.qe("en", "it", "This is an example", "Questo è un esempio")

score = mmt.qe("en", "it", "Hello world", "Ciao mondo")

qe, err := mmt.Qe("en", "it", "Hello world", "Ciao mondo")

QualityEstimation qe = mmt.qe("en", "it", "Hello world", "Ciao mondo");

var score = mmt.Qe("en", "it", "Hello world", "Ciao mondo");

$qe = $mmt->qe("en", "it", "Hello world", "Ciao mondo");

{
  "status": 200,
  "data": {
    "score": 0.854
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source": "en", "target":"it",
    "sentence":["Hello world", "This is an example"],
    "translation":["Ciao mondo", "Questo è un esempio"]}' \
    "https://api.modernmt.com/translate/qe"

const qes = await mmt.qe("en", "it",
    ["Hello world", "This is an example"], ["Ciao mondo", "Questo è un esempio"])

scores = mmt.qe("en", "it", ["Hello world", "This is an example"],
                ["Ciao mondo", "Questo è un esempio"])

qes, err := mmt.QeList("en", "it",
    []string{"Hello world", "This is an example"},
    []string{"Ciao mondo", "Questo è un esempio"})

List<QualityEstimation> qes = mmt.qe("en", "it",
        Arrays.asList("Hello world", "This is an example"),
        Arrays.asList("Ciao mondo", "Questo è un esempio"));

var scores = mmt.Qe("en", "it",
    new List<string>{"Hello world", "This is an example"},
    new List<string>{"Ciao mondo", "Questo è un esempio"});

$qes = $mmt->qe("en", "it",
    ["Hello world", "This is an example"], ["Ciao mondo", "Questo è un esempio"]);

{
  "status": 200,
  "data": [
    {
      "score": 0.902
    },
    {
      "score": 0.956
    }
  ]
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    -F "content=@path/to/text_file" \
    -F "source=en" \
    -F "targets=it" \
    -F "targets=es" \
    "https://api.modernmt.com/context-vector"

const contextVectors = await mmt.getContextVectorFromFile("en", ["es", "it"], "path/to/file.txt") // or ReadStream

context_vectors = mmt.get_context_vector_from_file("en", ["es", "it"], "path/to/file.txt")  # or stream

contextVectors, err := mmt.GetContextVectorsFromFilePath("en", []string{"es", "it"}, "path/to/file.txt", nil, 0, "") // or *os.File

String contextVectors = mmt.getContextVectorFromFile("en", Arrays.asList("es", "it"), "path/to/file.txt"); // or File

var contextVectors = mmt.GetContextVectorFromFile("en", new List<string>{"es", "it"}, "path/to/file.txt"); // or FileStream

$context_vectors = $mmt->get_context_vector_from_file("en", ["es", "it"], "path/to/file.txt");

{
  "status": 200,
  "data": {
    "source": "en",
    "vectors": {
      "it": "37787:0.191,37784:0.163,37790:0.14,37791:0.092"
    }
  }
}

curl -X POST \
    -H "X-HTTP-Method-Override: GET" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    -F "text=This is an example text for context vector computation" \
    -F "source=en" \
    -F "targets=it" \
    -F "targets=es" \
    "https://api.modernmt.com/context-vector"

const contextVectors = await mmt.getContextVector("en", ["es", "it"], "This is an example text for context vector computation")

context_vectors = mmt.get_context_vector("en", ["es", "it"], "This is an example text for context vector computation")

contextVectors, err := mmt.GetContextVectors("en", []string{"es", "it"}, "This is an example text for context vector computation", nil, 0)

String contextVectors = mmt.getContextVector("en", Arrays.asList("es", "it"), "This is an example text for context vector computation");

var contextVectors = mmt.GetContextVector("en", new List<string>{"es", "it"}, "This is an example text for context vector computation");

$context_vectors = $mmt->get_context_vector("en", ["es", "it"], "This is an example text for context vector computation");

{
  "status": 200,
  "data": {
    "source": "en",
    "vectors": {
      "it": "37790:0.167,37787:0.058,37784:0.054,37791:0.019"
    }
  }
}

# Management
GET /memories
GET /memories/:id
POST /memories
PUT /memories/:id
DELETE /memories/:id

# Content
POST /memories/:id/content
PUT /memories/:id/content

# Glossary
POST /memories/:id/glossary
PUT /memories/:id/glossary

GET /import-jobs/:id

curl -H "MMT-ApiKey: YOUR_API_KEY" "https://api.modernmt.com/memories"

const memories = await mmt.memories.list()

memories = mmt.memories.list()

memories, err := mmt.Memories.List()

List<Memory> memories = mmt.memories.list();

var memories = mmt.Memories.List();

$memories = $mmt->memories->get_all();

{
  "status": 200,
  "data": [
    {
      "id": 37784,
      "creationDate": "2021-03-19T09:46:59+00:00",
      "name": "legal"
    },
    ...
    {
      "id": 37791,
      "creationDate": "2021-03-19T09:47:21+00:00",
      "name": "medical"
    }
  ]
}

curl -H "MMT-ApiKey: YOUR_API_KEY" "https://api.modernmt.com/memories/37790"

const memory = await mmt.memories.get(37790)

memory = mmt.memories.get(37790)

memory, err := mmt.Memories.Get(37790)

Memory memory = mmt.memories.get(37790);

var memory = mmt.Memories.Get(37790);

$memory = $mmt->memories->get(37790);

{
  "status": 200,
  "data": {
    "id": 37790,
    "creationDate": "2021-03-19T09:46:59+00:00",
    "name": "legal"
  }
}

curl -X POST \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"name": "chemistry"}' \
    "https://api.modernmt.com/memories"

const memory = await mmt.memories.create("chemistry")

memory = mmt.memories.create("chemistry")

memory, err := mmt.Memories.Create("chemistry", "")

Memory memory = mmt.memories.create("chemistry");

var memory = mmt.Memories.Create("chemistry");

$memory = $mmt->memories->create("chemistry");

{
  "status": 200,
  "data": {
    "id": 37790,
    "creationDate": "2021-04-12T15:24:26+00:00",
    "name": "chemistry"
  }
}

curl -X PUT \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"name": "physical chemistry"}' \
    "https://api.modernmt.com/memories/37790"

const memory = await mmt.memories.edit(37790, "physical chemistry")

memory = mmt.memories.edit(37790, "physical chemistry")

memory, err := mmt.Memories.Edit("physical chemistry", "")

Memory memory = mmt.memories.edit(37790, "physical chemistry");

var memory = mmt.Memories.Edit(37790, "physical chemistry");

$memory = $mmt->memories->edit(37790, "physical chemistry");

{
  "status": 200,
  "data": {
    "id": 37790,
    "creationDate": "2021-04-12T15:24:26+00:00",
    "name": "physical chemistry"
  }
}

curl -X DELETE \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    "https://api.modernmt.com/memories/37790"

const memory = await mmt.memories.delete(37790)

memory = mmt.memories.delete(37790)

memory, err := mmt.Memories.Delete(37790)

Memory memory = mmt.memories.delete(37790);

var memory = mmt.Memories.Delete(37790);

$memory = $mmt->memories->delete(37790);

{
  "status": 200,
  "data": {
    "id": 37790,
    "creationDate": "2021-04-12T15:24:26+00:00",
    "name": "physical chemistry"
  }
}

curl -X POST \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    -F "tmx=@path/to/tmx_file" \
    "https://api.modernmt.com/memories/37790/content"

const importJob = await mmt.memories.import(37790, "path/to/file.tmx") // or ReadStream

import_job = mmt.memories.import_tmx(37790, "path/to/file.tmx")  # or stream

importJob, err := mmt.Memories.ImportTmxPath(37790, "path/to/file.tmx", "") // or *os.File

ImportJob importJob = mmt.memories.importTmx(37790, "path/to/file.tmx"); // or File

var importJob = mmt.Memories.Import(37790, "path/to/file.tmx"); // or FileStream

$import_job = $mmt->memories->import(37790, "path/to/file.tmx");

{
  "status": 200,
  "data": {
    "id": "00000000-0000-0000-0000-0000000379fc",
    "memory": 37790,
    "size": 18818,
    "progress": 0
  }
}

curl -X POST \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source":"en", "target":"it", "tuid":"1", "sentence":"This is a test.", "translation":"Questo è un test."}' \
    "https://api.modernmt.com/memories/37790/content"

const importJob = await mmt.memories.add(37790, "en", "it", "This is a test.", "Questo è un test.", "1")

import_job = mmt.memories.add(37790, "en", "it", "This is a test.", "Questo è un test.", "1")

importJob, err := mmt.Memories.Add(37790, "en", "it", "This is a test.", "Questo è un test.", "1")

ImportJob importJob = mmt.memories.add(37790, "en", "it", "This is a test.", "Questo è un test.", "1");

var importJob = mmt.Memories.Add(37790, "en", "it", "This is a test.", "Questo è un test.", "1");

$import_job = $mmt->memories->add(37790, "en", "it", "This is a test.", "Questo è un test.", "1");

{
  "status": 200,
  "data": {
    "id": "80000001-0000-0000-0000-0000049c6374",
    "memory": 37790,
    "size": 1,
    "progress": 0
  }
}

curl -X PUT \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"source":"en", "target":"it", "tuid":"1", "sentence":"This is a test.", "translation":"Questa è una prova."}' \
    "https://api.modernmt.com/memories/37790/content"

const importJob = await mmt.memories.replace(37790, "1", "en", "it", "This is a test.", "Questa è una prova.")

import_job = mmt.memories.replace(37790, "1", "en", "it", "This is a test.", "Questa è una prova.")

importJob, err := mmt.Memories.Replace(37790, "1", "en", "it", "This is a test.", "Questo è una prova.")

ImportJob importJob = mmt.memories.replace(37790, "1", "en", "it", "This is a test.", "Questa è una prova.");

var importJob = mmt.Memories.Add(37790, "1", "en", "it", "This is a test.", "Questa è una prova.");

$import_job = $mmt->memories->replace(37790, "1", "en", "it", "This is a test.", "Questa è una prova.");

{
  "status": 200,
  "data": {
    "id": "80000001-0000-0000-0000-0000049c7646",
    "memory": 37790,
    "size": 1,
    "progress": 0
  }
}

curl -X POST \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    -F "csv=@path/to/file.csv" \
    -F 'type=unidirectional' \
    "https://api.modernmt.com/memories/37790/glossary"

const importJob = await mmt.memories.importGlossary(37790, "/path/to/file.csv", "unidirectional"); // or ReadStream

import_job = mmt.memories.import_glossary(37790, "/path/to/file.csv", "unidirectional")  # or stream

importJob, err := mmt.Memories.ImportGlossaryPath(37790, "path/to/file.csv", "unidirectional", "") // or *os.File

ImportJob importJob = mmt.memories.importGlossary(37790, "path/to/file.csv", "unidirectional"); // or File

var importJob = mmt.Memories.ImportGlossary(37790, "path/to/file.csv", "unidirectional"); // or FileStream

$importJob = $mmt->memories->importGlossary(37790, "path/to/file.csv", "unidirectional");

{
  "status": 200,
  "data": {
    "id": "00000000-0000-0000-0000-0000000379fc",
    "memory": 37790,
    "size": 18818,
    "progress": 0
  }
}

curl -X POST \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"tuid":"1", "type":"equivalent",
    "terms":[{"term": "test", "language": "en"}, {"term": "prova", "language": "it"}, {"term": "prueba", "language": "es"}]}' \
    "https://api.modernmt.com/memories/37790/glossary"

const terms = [
    {term: "test", language: "en"},
    {term: "prova", language: "it"},
    {term: "prueba", language: "es"}
];

const importJob = await mmt.memories.addToGlossary(37790, terms, "equivalent", "1");

terms = [
    {"term": "test", "language": "en"},
    {"term": "prova", "language": "it"},
    {"term": "prueba", "language": "es"},
]

import_job = mmt.memories.add_to_glossary(37790, terms, "equivalent", "1")

terms := []GlossaryTerm{{
    Term:     "test",
    Language: "en",
}, {
    Term:     "prova",
    Language: "it",
}, {
    Term:     "prueba",
    Language: "es",
}}

importJob, err := mmt.Memories.AddToGlossary(37790, terms, "equivalent", "1")

List<GlossaryTerm> terms = new ArrayList<>();
terms.add(new GlossaryTerm("test", "en"));
terms.add(new GlossaryTerm("prova", "it"));
terms.add(new GlossaryTerm("prueba", "es"));

ImportJob importJob = mmt.memories.addToGlossary(37790, terms, "equivalent", "1");

var terms = new List<GlossaryTerm>
{
    new("test", "en"),
    new("prova", "it"),
    new("prueba", "es"),
};

var importJob = mmt.Memories.AddToGlossary(37790, terms, "equivalent", "1");

$terms = [
    ["term" => "test", "language" => "en"],
    ["term" => "prova", "language" => "it"],
    ["term" => "prueba", "language" => "es"]
];

$importJob = $mmt->memories->addToGlossary(37790, $terms, "equivalent", "1");

{
  "status": 200,
  "data": {
    "id": "80000001-0000-0000-0000-0000049c6374",
    "memory": 37790,
    "size": 1,
    "progress": 0
  }
}

curl -X PUT \
    -H "Content-Type: application/json" \
    -H "MMT-ApiKey: YOUR_API_KEY" \
    --data '{"tuid":"1", "type":"equivalent",
    "terms":[{"term": "test", "language": "en"}, {"term": "prova", "language": "it"}, {"term": "prueba", "language": "es"}]}' \
    "https://api.modernmt.com/memories/37790/glossary"

const terms = [
    {term: "test", language: "en"},
    {term: "prova", language: "it"},
    {term: "prueba", language: "es"}
];

const importJob = await mmt.memories.replaceInGlossary(37790, terms, "equivalent", "1");

terms = [
    {"term": "test", "language": "en"},
    {"term": "prova", "language": "it"},
    {"term": "prueba", "language": "es"},
]

import_job = mmt.memories.replace_in_glossary(37790, terms, "equivalent", "1")

terms := []GlossaryTerm{{
    Term:     "test",
    Language: "en",
}, {
    Term:     "prova",
    Language: "it",
}, {
    Term:     "prueba",
    Language: "es",
}}

importJob, err := mmt.Memories.ReplaceInGlossary(37790, terms, "equivalent", "1")

List<GlossaryTerm> terms = new ArrayList<>();
terms.add(new GlossaryTerm("test", "en"));
terms.add(new GlossaryTerm("prova", "it"));
terms.add(new GlossaryTerm("prueba", "es"));

ImportJob importJob = mmt.memories.replaceInGlossary(37790, terms, "equivalent", "1");

var terms = new List<GlossaryTerm>
{
    new("test", "en"),
    new("prova", "it"),
    new("prueba", "es"),
};

var importJob = mmt.Memories.ReplaceInGlossary(37790, terms, "equivalent", "1");

$terms = [
    ["term" => "test", "language" => "en"],
    ["term" => "prova", "language" => "it"],
    ["term" => "prueba", "language" => "es"]
];

$importJob = $mmt->memories->replaceInGlossary(37790, $terms, "equivalent", "1");

{
  "status": 200,
  "data": {
    "id": "80000001-0000-0000-0000-0000049c7646",
    "memory": 37790,
    "size": 1,
    "progress": 0
  }
}

[
    {
        "term": "test",
        "language": "en"
    },
    {
        "term": "prova",
        "language": "it"
    },
    {
        "term": "prueba",
        "language": "es"
    }
]

curl -H "MMT-ApiKey: YOUR_API_KEY" \
    "https://api.modernmt.com/import-jobs/00000000-0000-0000-0000-0000000379fc"

const importJob = await mmt.memories.getImportStatus("00000000-0000-0000-0000-0000000379fc")

import_job = mmt.memories.get_import_status("00000000-0000-0000-0000-0000000379fc")

importJob, err := mmt.Memories.GetImportStatus("00000000-0000-0000-0000-0000000379fc")

ImportJob importJob = mmt.memories.GetImportStatus("00000000-0000-0000-0000-0000000379fc");

var importJob = mmt.Memories.GetImportStatus("00000000-0000-0000-0000-0000000379fc");

$import_job = $mmt->memories->get_import_status("00000000-0000-0000-0000-0000000379fc");

{
  "status": 200,
  "data": {
    "id": "00000000-0000-0000-0000-0000000379fc",
    "memory": 37790,
    "size": 18818,
    "progress": 1
  }
}