ແປເອກະສານເປັນ API ພາສາປອກຕຸຍການ: ຄູ່ມືດ່ວນ ແລະ ງ່າຍ

ຄວາມສັບສົນທີ່ເຊື່ອງໄວ້ຂອງການແປເອກະສານແບບອັດຕະໂນມັດ

ການເຮັດໃຫ້ການແປໄຟລ໌ Document ຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການເປັນແບບອັດຕະໂນມັດແມ່ນມີອຸປະສັກດ້ານເຕັກນິກທີ່ສໍາຄັນ.
ນັກພັດທະນາຈໍານວນຫຼາຍມັກຈະປະເມີນຄວາມສັບສົນຕ່ຳເກີນໄປ, ໂດຍສົມມຸດວ່າມັນງ່າຍດາຍຄືກັບການດຶງຂໍ້ຄວາມ ແລະ ສົ່ງຜ່ານບໍລິການແປມາດຕະຖານ.
ຢ່າງໃດກໍ່ຕາມ, ວິທີການນີ້ມັກຈະນໍາໄປສູ່ໄຟລ໌ທີ່ເສຍຫາຍ, ການຈັດຮູບແບບທີ່ສູນເສຍໄປ, ແລະ ການແປທີ່ບໍ່ຖືກຕ້ອງທີ່ບໍ່ສາມາດບັນທຶກຄວາມແຕກຕ່າງທາງດ້ານພາສາໄດ້.

ສິ່ງທ້າທາຍຕົ້ນຕໍອັນໜຶ່ງແມ່ນການເຂົ້າລະຫັດຕົວອັກສອນ, ໂດຍສະເພາະກັບພາສາທີ່ມີເຄື່ອງໝາຍກຳກັບສຽງຫຼາຍເຊັ່ນ: ພາສາປອກຕຸຍການ.
ຕົວອັກສອນເຊັ່ນ ‘ç’, ‘ã’, ແລະ ‘é’ ສາມາດກາຍເປັນຂໍ້ມູນທີ່ບິດເບືອນໄດ້ຢ່າງງ່າຍດາຍ ຖ້າບໍ່ໄດ້ຖືກຈັດການດ້ວຍຂັ້ນຕອນການເຮັດວຽກຂອງ UTF-8 ທີ່ສອດຄ່ອງກັນ, ເຊິ່ງເຮັດໃຫ້ເນື້ອຫາບໍ່ສາມາດອ່ານໄດ້.
ຍິ່ງໄປກວ່ານັ້ນ, ໄຟລ໌ Document ບໍ່ແມ່ນໄຟລ໌ຂໍ້ຄວາມທໍາມະດາ; ມັນເປັນບ່ອນເກັບມ້ຽນທີ່ມີໂຄງສ້າງທີ່ບັນຈຸຂໍ້ມູນ XML, ຮູບແບບ, ຮູບພາບ, ແລະ ເມຕາເດຕາ ທີ່ກຳນົດຮູບແບບທັງໝົດ.

ການຮັກສາຮູບແບບທີ່ສັບສົນນີ້ອາດຈະເປັນສ່ວນທີ່ຍາກທີ່ສຸດຂອງຂະບວນການ.
ການດຶງຂໍ້ຄວາມແບບງ່າຍໆ ຈະບໍ່ສົນໃຈຕາຕະລາງ, ຫົວຂໍ້, ທ້າຍຂໍ້ຄວາມ, ຖັນ, ແລະ ຮູບພາບທີ່ຝັງໄວ້ທັງໝົດ, ເຊິ່ງເປັນສິ່ງສໍາຄັນຕໍ່ບໍລິບົດຂອງເອກະສານ ແລະ ຮູບລັກສະນະແບບມືອາຊີບ.
ການສ້າງເອກະສານຄືນໃໝ່ດ້ວຍຂໍ້ຄວາມທີ່ແປແລ້ວ ໃນຂະນະທີ່ຮັກສາການຈັດຮູບແບບຕົ້ນສະບັບ ຮຽກຮ້ອງໃຫ້ມີຄວາມເຂົ້າໃຈຢ່າງລະອຽດຂອງໂຄງສ້າງໄຟລ໌ພື້ນຖານ, ເຊິ່ງເປັນວຽກທີ່ໃຊ້ເວລາຫຼາຍ ແລະ ມີຄວາມສ່ຽງຕໍ່ຄວາມຜິດພາດໃນການພັດທະນາຕັ້ງແຕ່ເລີ່ມຕົ້ນ.

ແນະນໍາ Doctranslate API ສໍາລັບການແປພາສາປອກຕຸຍການທີ່ລຽບງ່າຍ

Doctranslate API ສະຫນອງການແກ້ໄຂບັນຫາທີ່ເຂັ້ມແຂງ ແລະ ສະຫງ່າງາມຕໍ່ສິ່ງທ້າທາຍເຫຼົ່ານີ້, ໂດຍສະເຫນີເຄື່ອງມືທີ່ມີປະສິດທິພາບທີ່ຖືກອອກແບບມາສະເພາະສໍາລັບການແປໄຟລ໌ທີ່ມີຄວາມຖືກຕ້ອງສູງ.
ໃນຖານະເປັນ RESTful API, ມັນຊ່ວຍໃຫ້ການເຊື່ອມໂຍງເຂົ້າກັບຊຸດຄໍາຮ້ອງສະຫມັກໃດໆໄດ້ຢ່າງງ່າຍດາຍ, ໂດຍໃຊ້ຄໍາຮ້ອງຂໍ HTTP ມາດຕະຖານ ແລະ ສົ່ງຄືນການຕອບສະໜອງ JSON ທີ່ຄາດເດົາໄດ້.
ນີ້ຊ່ວຍຫຼຸດຜ່ອນຄວາມສັບສົນຂອງຂະບວນການພັດທະນາ, ເຮັດໃຫ້ທ່ານສາມາດປະຕິບັດ API ເພື່ອແປໄຟລ໌ Document ຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການ ໂດຍບໍ່ຈໍາເປັນຕ້ອງເປັນຜູ້ຊ່ຽວຊານໃນຮູບແບບໄຟລ໌.

ບໍ່ເໝືອນກັບ API ແປຂໍ້ຄວາມທົ່ວໄປ, Doctranslate ຈະວິເຄາະໂຄງສ້າງເອກະສານທັງໝົດຢ່າງສະຫຼາດ, ລະບຸ ແລະ ແປສະເພາະເນື້ອໃນຂໍ້ຄວາມເທົ່ານັ້ນ.
ຈາກນັ້ນ API ຈະສ້າງໄຟລ໌ຄືນໃໝ່ຢ່າງລະມັດລະວັງ, ຮັບປະກັນວ່າການຈັດຮູບແບບຕົ້ນສະບັບທັງໝົດ, ຕັ້ງແຕ່ຕາຕະລາງ ແລະ ຖັນ ຈົນເຖິງຕົວອັກສອນ ແລະ ຮູບພາບ, ຍັງຄົງຢູ່ໃນສະພາບທີ່ສົມບູນ.
ຂະບວນການນີ້ຮັບປະກັນວ່າເອກະສານພາສາປອກຕຸຍການສຸດທ້າຍແມ່ນຮູບພາບສະທ້ອນຂອງແຫຼ່ງພາສາອັງກິດໃນທຸກຢ່າງຍົກເວັ້ນພາສາ, ຊ່ວຍປະຢັດເວລາການເຮັດວຽກຄືນໃໝ່ດ້ວຍຕົນເອງຫຼາຍຊົ່ວໂມງ.

ນອກຈາກນັ້ນ, API ດໍາເນີນການໃນຮູບແບບ asynchronous, ເຊິ່ງເປັນສິ່ງຈໍາເປັນສໍາລັບການຈັດການເອກະສານຂະໜາດໃຫຍ່ ຫຼື ຊັບຊ້ອນຢ່າງມີປະສິດທິພາບ.
ທ່ານສາມາດສົ່ງວຽກແປ ແລະ ຮັບ Job ID ທີ່ເປັນເອກະລັກ, ເຮັດໃຫ້ຄໍາຮ້ອງສະຫມັກຂອງທ່ານສາມາດສືບຕໍ່ການດໍາເນີນງານໄດ້ໂດຍບໍ່ມີການຖືກບລັອກ.
ທ່ານສາມາດສອບຖາມສະຖານະຂອງວຽກ ຫຼື ຕັ້ງຄ່າ webhook ສໍາລັບການແຈ້ງເຕືອນແບບສົດໆ, ໃຫ້ຂັ້ນຕອນການເຮັດວຽກທີ່ປັບຂະໜາດໄດ້ ແລະ ບໍ່ມີການບລັອກ ເຊິ່ງເໝາະສຳລັບແອັບພລິເຄຊັນທີ່ທັນສະໄໝ ແລະ ມີປະສິດທິພາບສູງ.

ຄູ່ມືເທື່ອລະຂັ້ນຕອນ: ການເຊື່ອມໂຍງ API ເພື່ອແປເອກະສານຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການ

ການເຊື່ອມໂຍງ Doctranslate API ເຂົ້າໃນໂຄງການຂອງທ່ານແມ່ນຂະບວນການທີ່ຊັດເຈນ ແລະ ມີເຫດຜົນ.
ຄູ່ມືນີ້ຈະນໍາພາທ່ານຜ່ານຂັ້ນຕອນທີ່ສໍາຄັນ, ຈາກການກວດສອບສິດທິ ຈົນເຖິງການດາວໂຫຼດໄຟລ໌ທີ່ແປແລ້ວຂອງທ່ານ, ໂດຍໃຊ້ Python ເປັນຕົວຢ່າງ.
ຂັ້ນຕອນການເຮັດວຽກພື້ນຖານຍັງຄົງຄືເກົ່າ ບໍ່ວ່າທ່ານຈະເລືອກພາສາການຂຽນໂປຣແກຣມໃດກໍຕາມ, ເນື່ອງຈາກວ່າມັນແມ່ນອີງໃສ່ຫຼັກການ REST ມາດຕະຖານ.

ຂັ້ນຕອນທີ 1: ການກວດສອບສິດທິ ແລະ ການຕັ້ງຄ່າ

ກ່ອນທີ່ຈະໂທຫາ API ໃດໆກໍຕາມ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ຮັບ API key ຂອງທ່ານຈາກແຜງຄວບຄຸມນັກພັດທະນາ Doctranslate.
key ນີ້ກວດສອບຄໍາຮ້ອງຂໍຂອງທ່ານ ແລະ ຄວນເກັບຮັກສາເປັນຄວາມລັບ, ໂດຍປົກກະຕິແລ້ວແມ່ນເກັບໄວ້ເປັນຕົວແປສະພາບແວດລ້ອມໃນຄໍາຮ້ອງສະຫມັກຂອງທ່ານ.
ທ່ານຈະລວມ key ນີ້ຢູ່ໃນ header ຂອງທຸກໆຄໍາຮ້ອງຂໍ ເພື່ອອະນຸຍາດການເຂົ້າເຖິງບໍລິການ API ຂອງທ່ານ.

ຂັ້ນຕອນທີ 2: ອັບໂຫຼດເອກະສານພາສາອັງກິດຂອງທ່ານ

ຂັ້ນຕອນທໍາອິດໃນຂັ້ນຕອນການເຮັດວຽກການແປແມ່ນການອັບໂຫຼດໄຟລ໌ Document ຕົ້ນສະບັບ.
ທ່ານຈະສົ່ງຄໍາຮ້ອງຂໍ POST ໄປຫາ endpoint /v2/document/upload ໂດຍມີໄຟລ໌ລວມເປັນ multipart/form-data.
ຄໍາຮ້ອງຂໍທີ່ສໍາເລັດຈະສົ່ງຄືນ document_id, ເຊິ່ງທ່ານຈະໃຊ້ເປັນການອ້າງອີງສໍາລັບການດໍາເນີນງານຕໍ່ມາທັງໝົດໃນໄຟລ໌ສະເພາະນັ້ນ.

ຂັ້ນຕອນທີ 3: ເລີ່ມຕົ້ນວຽກງານການແປ

ດ້ວຍ document_id ຢູ່ໃນມື, ຕອນນີ້ທ່ານສາມາດຮ້ອງຂໍການແປໄດ້.
ທ່ານຈະເຮັດຄໍາຮ້ອງຂໍ POST ໄປຫາ endpoint /v2/document/translate, ໂດຍກໍານົດ document_id, the source_language (‘en’), ແລະ the target_language (‘pt’).
API ຈະຕອບສະໜອງທັນທີດ້ວຍ job_id, ຢືນຢັນວ່າວຽກງານການແປຂອງທ່ານໄດ້ຖືກຈັດຄິວເພື່ອປະມວນຜົນແລ້ວ.

ຂັ້ນຕອນທີ 4: ກວດສອບສະຖານະການແປ

ເນື່ອງຈາກການແປເປັນຂະບວນການ asynchronous, ທ່ານຈໍາເປັນຕ້ອງກວດສອບສະຖານະຂອງວຽກຂອງທ່ານ.
ທ່ານສາມາດເຮັດໄດ້ໂດຍການສົ່ງຄໍາຮ້ອງຂໍ GET ໄປຫາ endpoint /v2/document/status/{job_id}, ໂດຍການປ່ຽນແທນ {job_id} ດ້ວຍ ID ທີ່ທ່ານໄດ້ຮັບໃນຂັ້ນຕອນກ່ອນໜ້ານີ້.
ສະຖານະຈະເປັນ ‘processing’ ໃນຂະນະທີ່ວຽກກຳລັງດໍາເນີນຢູ່ ແລະ ຈະປ່ຽນເປັນ ‘completed’ ເມື່ອເອກະສານພາສາປອກຕຸຍການພ້ອມແລ້ວ.

ຂັ້ນຕອນທີ 5: ດາວໂຫຼດເອກະສານພາສາປອກຕຸຍການທີ່ແປແລ້ວ

ເມື່ອສະຖານະວຽກແມ່ນ ‘completed’, ທ່ານສາມາດດຶງເອົາໄຟລ໌ທີ່ແປແລ້ວຂອງທ່ານ.
ເຮັດຄໍາຮ້ອງຂໍ GET ໄປຫາ endpoint /v2/document/download/{document_id}, ໂດຍໃຊ້ document_id ຕົ້ນສະບັບຈາກຂັ້ນຕອນການອັບໂຫຼດ.
ອັນນີ້ຈະຖ່າຍທອດຂໍ້ມູນຖານສອງຂອງໄຟລ໌ .docx ທີ່ແປແລ້ວ, ເຊິ່ງທ່ານສາມາດບັນທຶກໄວ້ໃນທ້ອງຖິ່ນ ຫຼື ໃຫ້ບໍລິການແກ່ຜູ້ໃຊ້ຂອງທ່ານໄດ້.

ຕົວຢ່າງລະຫັດ Python ທີ່ສົມບູນ

ນີ້ແມ່ນສະຄຣິບ Python ທີ່ສົມບູນທີ່ສະແດງໃຫ້ເຫັນຂັ້ນຕອນການເຮັດວຽກທັງໝົດ.
ຕົວຢ່າງນີ້ໃຊ້ຫ້ອງສະໝຸດ requests ທີ່ນິຍົມ ເພື່ອຈັດການຄໍາຮ້ອງຂໍ HTTP, ສະໜອງແມ່ແບບພາກປະຕິບັດສໍາລັບການປະຕິບັດຂອງທ່ານເອງ.
ຢ່າລືມປ່ຽນແທນ 'YOUR_API_KEY' ແລະ 'path/to/your/document.docx' ດ້ວຍຂໍ້ມູນປະຈຳຕົວ ແລະ ເສັ້ນທາງໄຟລ໌ຕົວຈິງຂອງທ່ານ.

import requests
import time
import os

# Replace with your actual API key and file path
API_KEY = os.getenv('DOCTRANSLATE_API_KEY', 'YOUR_API_KEY')
FILE_PATH = 'path/to/your/document.docx'
BASE_URL = 'https://developer.doctranslate.io/api'

HEADERS = {
    'Authorization': f'Bearer {API_KEY}'
}

def upload_document(file_path):
    """Uploads a document and returns the document_id."""
    print(f"Uploading document: {file_path}")
    with open(file_path, 'rb') as f:
        files = {'file': (os.path.basename(file_path), f)}
        response = requests.post(f"{BASE_URL}/v2/document/upload", headers=HEADERS, files=files)
    
    response.raise_for_status() # Raises an exception for bad status codes
    document_id = response.json().get('document_id')
    print(f"Successfully uploaded. Document ID: {document_id}")
    return document_id

def translate_document(document_id):
    """Starts the translation job and returns the job_id."""
    print("Starting translation to Portuguese...")
    payload = {
        'document_id': document_id,
        'source_language': 'en',
        'target_language': 'pt'
    }
    response = requests.post(f"{BASE_URL}/v2/document/translate", headers=HEADERS, json=payload)
    response.raise_for_status()
    job_id = response.json().get('job_id')
    print(f"Translation job started. Job ID: {job_id}")
    return job_id

def check_status(job_id):
    """Polls the job status until it's completed."""
    while True:
        print("Checking translation status...")
        response = requests.get(f"{BASE_URL}/v2/document/status/{job_id}", headers=HEADERS)
        response.raise_for_status()
        status = response.json().get('status')
        print(f"Current status: {status}")
        if status == 'completed':
            print("Translation completed!")
            break
        elif status == 'failed':
            raise Exception("Translation job failed.")
        time.sleep(5) # Wait for 5 seconds before checking again

def download_document(document_id, output_path):
    """Downloads the translated document."""
    print(f"Downloading translated document to {output_path}...")
    response = requests.get(f"{BASE_URL}/v2/document/download/{document_id}", headers=HEADERS, stream=True)
    response.raise_for_status()
    with open(output_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Download complete.")

if __name__ == "__main__":
    try:
        doc_id = upload_document(FILE_PATH)
        job_id = translate_document(doc_id)
        check_status(job_id)
        
        # Define the output file path
        output_file = os.path.join(os.path.dirname(FILE_PATH), "translated_document_pt.docx")
        download_document(doc_id, output_file)
        
    except requests.exceptions.HTTPError as e:
        print(f"An API error occurred: {e.response.status_code} {e.response.text}")
    except Exception as e:
        print(f"An error occurred: {e}")


ຂໍ້ຄວນພິຈາລະນາທີ່ສໍາຄັນໃນເວລາຈັດການລັກສະນະສະເພາະຂອງພາສາປອກຕຸຍການ
ການແປເນື້ອໃນເປັນພາສາປອກຕຸຍການຮຽກຮ້ອງໃຫ້ມີຫຼາຍກວ່າການປ່ຽນຄຳສັບແບບຕົວອັກສອນຕໍ່ຕົວອັກສອນ.
 ພາສາດັ່ງກ່າວມີຄວາມສັບສົນທາງໄວຍາກອນ ແລະ ຄວາມລະອຽດອ່ອນທາງດ້ານວັດທະນະທໍາທີ່ຕ້ອງໄດ້ຮັບການເຄົາລົບ ເພື່ອຜະລິດເອກະສານທີ່ມີຄຸນນະພາບສູງ ແລະ ມີສຽງທີ່ເປັນທໍາມະຊາດ.
 Doctranslate API ແມ່ນຂັບເຄື່ອນໂດຍເຄື່ອງຈັກແປພາສາເຄື່ອງຈັກທີ່ກ້າວໜ້າ ເຊິ່ງໄດ້ຮັບການຝຶກອົບຮົມເພື່ອຈັດການກັບຄວາມສັບສົນເຫຼົ່ານີ້ດ້ວຍຄວາມຖືກຕ້ອງສູງ.
ລັກສະນະທີ່ສໍາຄັນຂອງພາສາປອກຕຸຍການແມ່ນການນໍາໃຊ້ຄໍານາມທີ່ມີເພດ ແລະ ຄວາມສອດຄ່ອງຂອງຄໍາສະແດງ ແລະ ຄໍາຄຸນນາມທີ່ສອດຄ້ອງກັນ.
 ຕົວຢ່າງ, ‘o livro novo’ (ປຶ້ມໃໝ່) ແມ່ນເພດຊາຍ, ໃນຂະນະທີ່ ‘a casa nova’ (ເຮືອນໃໝ່) ແມ່ນເພດຍິງ.
 ເຄື່ອງມືແປພາສາແບບງ່າຍໆອາດຈະລົ້ມເຫຼວໃນການສ້າງການເຊື່ອມຕໍ່ເຫຼົ່ານີ້ຢ່າງຖືກຕ້ອງ, ແຕ່ເຄື່ອງຈັກທີ່ຊັບຊ້ອນເຂົ້າໃຈບໍລິບົດທາງໄວຍາກອນ, ຮັບປະກັນວ່າຄໍາສັບທັງໝົດໃນປະໂຫຍກສອດຄ່ອງກັນຢ່າງຖືກຕ້ອງ.
ຮູບແບບທາງການເປັນຂໍ້ຄວນພິຈາລະນາທີ່ສໍາຄັນອີກອັນໜຶ່ງ, ດ້ວຍຄວາມແຕກຕ່າງທີ່ໜ້າສັງເກດລະຫວ່າງພາສາປອກຕຸຍການເອີຣົບ ແລະ ພາສາປອກຕຸຍການບຣາຊິລ.
 ໃນຂະນະທີ່ API ມັກຈະຕັ້ງຄ່າເລີ່ມຕົ້ນເປັນສໍານຽງທີ່ນິຍົມທີ່ສຸດ, ແບບຈໍາລອງພື້ນຖານຂອງມັນຮູ້ເຖິງຄວາມແຕກຕ່າງເຫຼົ່ານີ້, ເຊັ່ນ: ການໃຊ້ ‘tu’ ທຽບກັບ ‘você’.
 ຄວາມຮັບຮູ້ດ້ານພາສານີ້ນໍາໄປສູ່ການແປທີ່ບໍ່ພຽງແຕ່ຖືກຕ້ອງຕາມໄວຍາກອນເທົ່ານັ້ນ ແຕ່ຍັງເໝາະສົມທາງດ້ານວັດທະນະທໍາສໍາລັບຜູ້ຊົມເປົ້າໝາຍ. ສໍາລັບຄໍາຮ້ອງສະຫມັກທີ່ຕ້ອງການຂັ້ນຕອນການເຮັດວຽກການຈັດທ້ອງຖິ່ນທີ່ເຂັ້ມແຂງ ແລະ ເຊື່ອຖືໄດ້, ທ່ານສາມາດປັບປຸງຂະບວນການທັງໝົດຂອງທ່ານດ້ວຍ ຄວາມສາມາດໃນການແປເອກະສານທີ່ມີປະສິດທິພາບທີ່ສະເໜີໃຫ້ໂດຍ Doctranslate.io, ຮັບປະກັນຄວາມສອດຄ່ອງ ແລະ ຄຸນນະພາບໃນທົ່ວໂຄງການຂອງທ່ານທັງໝົດ.
ສະຫຼຸບ: ປັບປຸງຂັ້ນຕອນການເຮັດວຽກການແປຂອງທ່ານໃຫ້ລຽບງ່າຍ
ການເຮັດໃຫ້ການແປໄຟລ໌ Document ຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການເປັນແບບອັດຕະໂນມັດແມ່ນເປັນວຽກທີ່ສັບສົນ, ແຕ່ມັນກາຍເປັນສິ່ງທີ່ສາມາດເຮັດໄດ້ ແລະ ມີປະສິດທິພາບດ້ວຍເຄື່ອງມືທີ່ຖືກຕ້ອງ.
 Doctranslate API ໄດ້ສະຫຼຸບຄວາມຫຍຸ້ງຍາກຂອງການວິເຄາະໄຟລ໌, ການຮັກສາຮູບແບບ, ແລະ ຄວາມສັບສົນທາງດ້ານພາສາ, ຊ່ວຍໃຫ້ທ່ານສາມາດສຸມໃສ່ການສ້າງຄຸນສົມບັດຫຼັກຂອງຄໍາຮ້ອງສະຫມັກຂອງທ່ານ.
 ໂດຍການປະຕິບັດຕາມຄູ່ມືເທື່ອລະຂັ້ນຕອນ, ທ່ານສາມາດເຊື່ອມໂຍງບໍລິການແປເອກະສານທີ່ມີປະສິດທິພາບ, ປັບຂະໜາດໄດ້, ແລະ ຖືກຕ້ອງໄດ້ຢ່າງວ່ອງໄວ.
ວິທີການນີ້ບໍ່ພຽງແຕ່ເລັ່ງກຳນົດເວລາການພັດທະນາຂອງທ່ານເທົ່ານັ້ນ ແຕ່ຍັງຮັບປະກັນຜະລິດຕະພັນສຸດທ້າຍທີ່ມີຄຸນນະພາບສູງກວ່າອີກດ້ວຍ.
 ທ່ານສາມາດຈັດສົ່ງເອກະສານພາສາປອກຕຸຍການທີ່ຈັດຮູບແບບຢ່າງເປັນມືອາຊີບໄດ້ຢ່າງໝັ້ນໃຈ ເຊິ່ງຮັກສາຄວາມສົມບູນ ແລະ ເຈດຕະນາຂອງວັດສະດຸຕົ້ນສະບັບ.
 ເພື່ອສໍາຫຼວດຄຸນສົມບັດຂັ້ນສູງເພີ່ມເຕີມ, ເຊັ່ນ: webhooks, ຄໍາສັບສະເພາະທີ່ກໍານົດເອງ, ແລະ ຮູບແບບໄຟລ໌ເພີ່ມເຕີມ, ໃຫ້ແນ່ໃຈວ່າໄດ້ປຶກສາເອກະສານ Doctranslate API ຢ່າງເປັນທາງການ.