API แปลเอกสาร: แปลภาษาอังกฤษเป็นภาษาโปรตุเกสอย่างรวดเร็ว

เหตุใดการแปลเอกสารผ่าน API จึงมีความซับซ้อนอย่างคาดไม่ถึง

การแปลอัตโนมัติจากภาษาอังกฤษเป็นภาษาโปรตุเกสดูเหมือนง่าย แต่ในไม่ช้าผู้พัฒนาก็ต้องเผชิญกับอุปสรรคสำคัญ
Document Translation API ที่แข็งแกร่งต้องทำมากกว่าแค่การแทนที่คำ แต่ต้องรักษาแก่นแท้ของเอกสารไว้ด้วย
ความท้าทายหลักเกี่ยวข้องกับการรักษาความสมบูรณ์ของไฟล์ การจัดการเลย์เอาต์ภาพที่ซับซ้อน และการประมวลผลการเข้ารหัสอักขระเฉพาะสำหรับภาษาโปรตุเกสอย่างถูกต้อง

การไม่จัดการปัญหาเหล่านี้อาจส่งผลให้ไฟล์เสียหาย เลย์เอาต์เสีย และข้อความอ่านไม่ได้ ทำให้การแปลไร้ประโยชน์
API แปลข้อความแบบธรรมดาไม่เพียงพอสำหรับการจัดการไฟล์ที่มีโครงสร้าง เช่น DOCX, PDF หรือ PPTX
รูปแบบไฟล์แต่ละรูปแบบมีโครงสร้างภายในที่เป็นเอกลักษณ์ซึ่งต้องมีการแยกวิเคราะห์และการสร้างใหม่ที่ระมัดระวังเพื่อหลีกเลี่ยงการสูญหายของข้อมูลหรือข้อผิดพลาดในการจัดรูปแบบในระหว่างกระบวนการแปล

ความท้าทายของการเข้ารหัสอักขระ

ภาษาโปรตุเกสอุดมไปด้วยเครื่องหมายกำกับเสียง เช่น ซีดิลลา (ç), ทิลเดส (ã, õ) และเครื่องหมายเน้นเสียงต่างๆ (á, ê, í)
หาก API ไม่จัดการการเข้ารหัส UTF-8 อย่างถูกต้อง อักขระเหล่านี้อาจกลายเป็นข้อความที่ผิดเพี้ยน ซึ่งเป็นปรากฏการณ์ที่เรียกว่า mojibake
สิ่งนี้ส่งผลกระทบต่อความเป็นมืออาชีพและความสามารถในการอ่านของเอกสารฉบับสุดท้ายทันที ทำให้เกิดประสบการณ์ผู้ใช้ที่ไม่ดีและส่งผลเสียต่อแอปพลิเคชัน

นอกจากนี้ API ต้องจัดการเครื่องหมายลำดับไบต์ (BOM) และความละเอียดอ่อนในการเข้ารหัสอื่นๆ ที่แตกต่างกันไปในแต่ละระบบ
นักพัฒนาที่สร้างเวิร์กโฟลว์การแปลต้องคำนึงถึงข้อผิดพลาดที่อาจเกิดขึ้นเหล่านี้ตั้งแต่เริ่มต้น
หากไม่มีโซลูชันเฉพาะทาง มักจะหมายถึงการเขียนสคริปต์ก่อนการประมวลผลและหลังการประมวลผลจำนวนมากเพียงเพื่อจัดการการเข้ารหัสข้อความอย่างถูกต้อง ซึ่งเพิ่มภาระในการพัฒนาอย่างมาก

การรักษารูปแบบเอกสารที่ซับซ้อน

เอกสารเป็นมากกว่าแค่ข้อความ แต่ประกอบด้วยตาราง แผนภูมิ ส่วนหัว ส่วนท้าย รูปภาพพร้อมคำบรรยาย และเลย์เอาต์หลายคอลัมน์
แนวทางการแปลแบบง่ายๆ ที่ดึงข้อความออกแล้วใส่กลับเข้าไปใหม่เกือบจะทำลายโครงสร้างที่ละเอียดอ่อนนี้อย่างแน่นอน
ตัวอย่างเช่น ข้อความภาษาโปรตุเกสมักจะยาวกว่าข้อความภาษาอังกฤษที่เทียบเท่ากัน ซึ่งอาจทำให้ข้อความล้นออกจากคอนเทนเนอร์ที่กำหนด คอลัมน์ไม่ตรงแนว หรือผลักรูปภาพออกจากหน้า

Document Translation API ที่ซับซ้อนจำเป็นต้องรับรู้ถึงเลย์เอาต์ โดยจัดเรียงข้อความใหม่ได้อย่างชาญฉลาดในขณะที่เคารพการออกแบบดั้งเดิม
สิ่งนี้ต้องอาศัยความเข้าใจอย่างลึกซึ้งเกี่ยวกับรูปแบบไฟล์ เช่น DOCX (Office Open XML), แบบจำลองวัตถุ PDF และโครงสร้างสไลด์งานนำเสนอ
การสร้างเอกสารใหม่หลังการแปลในขณะที่รักษาการจัดรูปแบบดั้งเดิมไว้เป็นความสำเร็จทางวิศวกรรมที่ไม่ธรรมดา ซึ่งควรปล่อยให้เป็นหน้าที่ของบริการเฉพาะทาง

การสำรวจโครงสร้างไฟล์ภายใน

ภายใต้พื้นผิว ไฟล์ DOCX ธรรมดาคือไฟล์เก็บถาวร zip ที่ซับซ้อนซึ่งประกอบด้วยไฟล์ XML, เนื้อหาสื่อ และข้อมูลเชิงสัมพันธ์หลายไฟล์
การแปลเนื้อหาจำเป็นต้องแยกวิเคราะห์โครงสร้างนี้ ระบุโหนดข้อความที่แปลได้ในขณะที่ละเว้นแท็กโครงสร้าง จากนั้นสร้างไฟล์เก็บถาวรขึ้นใหม่ให้สมบูรณ์แบบ
ข้อผิดพลาดใดๆ ในกระบวนการนี้ เช่น แท็กที่ไม่ตรงกันหรือการอ้างอิงที่ไม่ถูกต้อง อาจนำไปสู่ไฟล์ที่เสียหายซึ่งไม่สามารถเปิดได้โดยซอฟต์แวร์มาตรฐาน เช่น Microsoft Word

ในทำนองเดียวกัน PDF ก็มีความท้าทายในตัวเอง โดยข้อความมักจะถูกจัดเก็บในวัตถุที่แยกส่วนซึ่งถูกกำหนดตำแหน่งแบบสัมบูรณ์บนหน้า
การดึงและแทนที่ข้อความนี้ต้องใช้เครื่องมือเรนเดอร์ที่ซับซ้อนเพื่อให้แน่ใจว่าเนื้อหาที่แปลแล้วถูกวางอย่างถูกต้อง
การสร้างตรรกะนี้ด้วยตนเองต้องใช้ทรัพยากรมากและมีแนวโน้มที่จะเกิดข้อผิดพลาด ทำให้ API เฉพาะทางเป็นเครื่องมือสำคัญสำหรับเวิร์กโฟลว์การแปลเอกสารที่เชื่อถือได้

ขอแนะนำ Doctranslate API สำหรับการแปลเอกสาร

Doctranslate API คือโซลูชันที่สร้างขึ้นโดยเฉพาะเพื่อเอาชนะความซับซ้อนทั้งหมดของการแปลเอกสาร
มันทำงานเป็น RESTful API ที่เรียบง่ายแต่ทรงพลัง ซึ่งช่วยให้นักพัฒนาสามารถรวมการแปลคุณภาพสูงที่รักษารูปแบบได้โดยตรงในแอปพลิเคชันของตน
แทนที่จะต้องต่อสู้กับตัวแยกวิเคราะห์ไฟล์และปัญหาการเข้ารหัส คุณสามารถมุ่งเน้นไปที่ตรรกะของแอปพลิเคชันหลักของคุณ ในขณะที่เราจัดการงานหนักในการประมวลผลไฟล์

API ของเรารับรูปแบบเอกสารที่หลากหลาย ประมวลผลเนื้อหาโดยใช้เครื่องมือแปลขั้นสูง และสร้างไฟล์ขึ้นใหม่โดยมีการรวมข้อความที่แปลแล้วไว้อย่างราบรื่น
กระบวนการทั้งหมดได้รับการจัดการผ่านคำขอ HTTP ที่ตรงไปตรงมา พร้อมการตอบกลับ JSON ที่ชัดเจนเพื่อติดตามสถานะของงานแปลของคุณ
แนวทางที่เน้นนักพัฒนานี้รับประกันการผสานรวมที่รวดเร็วและมีประสิทธิภาพ ช่วยประหยัดเวลาและความพยายามในการพัฒนาหลายร้อยชั่วโมง

ด้วยการใช้ประโยชน์จากบริการของเรา คุณจะสามารถเข้าถึงระบบที่เข้าใจความแตกต่างของทั้งโครงสร้างไฟล์และบริบททางภาษา
ตั้งแต่การจัดการเครื่องหมายกำกับเสียงภาษาโปรตุเกสได้อย่างสมบูรณ์แบบไปจนถึงการปรับรูปแบบเพื่อรองรับการขยายข้อความ API ช่วยให้มั่นใจว่าเอกสารฉบับสุดท้ายมีความเป็นมืออาชีพและพร้อมใช้งาน
สำหรับภาพรวมที่ครอบคลุมเกี่ยวกับวิธีเพิ่มความสามารถในการแปลที่ทรงพลังให้กับโครงการของคุณ คุณสามารถ สำรวจโซลูชันการแปลเอกสารอันทรงพลังของเรา และดูว่าคุณสามารถเริ่มต้นได้อย่างง่ายดายเพียงใด

คำแนะนำทีละขั้นตอน: การผสานรวมการแปลภาษาอังกฤษเป็นภาษาโปรตุเกส

การผสานรวม Document Translation API ของเราเข้ากับแอปพลิเคชันของคุณเป็นกระบวนการที่เรียบง่ายและมีหลายขั้นตอน
คู่มือนี้จะแนะนำคุณเกี่ยวกับการตรวจสอบสิทธิ์ การอัปโหลดเอกสารเพื่อแปล การตรวจสอบสถานะ และการดาวน์โหลดผลลัพธ์สุดท้าย
เราจะใช้ Python พร้อมกับไลบรารี `requests` ยอดนิยม เพื่อสาธิตการใช้งานจริงที่คุณสามารถปรับใช้กับโครงการของคุณเองได้

ขั้นตอนที่ 1: การตรวจสอบสิทธิ์และการตั้งค่า

ก่อนทำการเรียกใช้ API ใดๆ คุณต้องรับคีย์ API เฉพาะของคุณจากแดชบอร์ด Doctranslate ของคุณ
คีย์นี้จะต้องรวมอยู่ในส่วนหัว `X-API-Key` ของคำขอทุกครั้งเพื่อตรวจสอบสิทธิ์แอปพลิเคชันของคุณ
ตรวจสอบให้แน่ใจว่าได้จัดเก็บคีย์ API ของคุณอย่างปลอดภัย เช่น เป็นตัวแปรสภาพแวดล้อม แทนที่จะฮาร์ดโค้ดลงในซอร์สโค้ดของคุณโดยตรง

สำหรับตัวอย่างนี้ เราจะตั้งค่าสภาพแวดล้อม Python ของเราโดยการนำเข้าไลบรารีที่จำเป็นและกำหนดคีย์ API และ URL พื้นฐานของเรา
การตั้งค่าเริ่มต้นนี้ช่วยให้มั่นใจว่าโค้ดของเราสะอาด จัดระเบียบ และพร้อมสำหรับขั้นตอนต่อไป
เราจะกำหนดพาธไฟล์สำหรับเอกสารที่เราตั้งใจจะแปลจากภาษาอังกฤษเป็นภาษาโปรตุเกสด้วย

import requests
import time
import os

# Securely load your API key from an environment variable
API_KEY = os.getenv("DOCTRANSLATE_API_KEY")
BASE_URL = "https://developer.doctranslate.io/v2"

# Check if the API key is set
if not API_KEY:
    raise ValueError("DOCTRANSLATE_API_KEY environment variable not set.")

HEADERS = {
    "X-API-Key": API_KEY
}

SOURCE_FILE_PATH = "path/to/your/english_document.docx"
TARGET_FILE_PATH = "path/to/your/portuguese_document.docx"

ขั้นตอนที่ 2: การอัปโหลดเอกสารสำหรับการแปล
ขั้นตอนแรกที่ใช้งานคือการอัปโหลดเอกสารต้นฉบับของคุณไปยัง API
 ทำได้โดยการส่งคำขอ `POST` ไปยังจุดสิ้นสุด `/v2/documents`
 คำขอต้องเป็นคำขอ `multipart/form-data` ที่มีไฟล์นั้นเอง `source_language` (‘EN’) และ `target_language` (‘PT’)
API จะประมวลผลการอัปโหลด และหากสำเร็จ จะตอบกลับด้วยวัตถุ JSON
 การตอบกลับนี้มี `documentId` ที่ไม่ซ้ำกัน ซึ่งสำคัญสำหรับการติดตามความคืบหน้าการแปลและการดาวน์โหลดไฟล์สุดท้าย
 คุณต้องจัดเก็บ `documentId` นี้เพื่อใช้ในการเรียก API ครั้งต่อไปสำหรับการตรวจสอบสถานะและการดึงข้อมูล

def upload_document(file_path):
    """Uploads a document and returns the document ID."""
    print(f"Uploading document: {file_path}")
    try:
        with open(file_path, "rb") as f:
            files = {"file": (os.path.basename(file_path), f)}
            data = {
                "source_language": "EN",
                "target_language": "PT"
            }
            response = requests.post(f"{BASE_URL}/documents", headers=HEADERS, files=files, data=data)
            response.raise_for_status() # Raises an HTTPError for bad responses (4xx or 5xx)
            
            response_data = response.json()
            document_id = response_data.get("documentId")
            print(f"Successfully uploaded document. Document ID: {document_id}")
            return document_id
    except requests.exceptions.RequestException as e:
        print(f"An error occurred during upload: {e}")
        return None

ขั้นตอนที่ 3: การตรวจสอบสถานะการแปล
การแปลเอกสารเป็นกระบวนการแบบอะซิงโครนัส โดยเฉพาะอย่างยิ่งสำหรับไฟล์ขนาดใหญ่หรือซับซ้อน
 หลังจากการอัปโหลด คุณต้องตรวจสอบสถานะการแปลเป็นระยะโดยการส่งคำขอ `GET` ไปยัง `/v2/documents/{documentId}`
 จุดสิ้นสุดนี้จะส่งกลับวัตถุ JSON ที่มี `status` ปัจจุบันของงานแปล ซึ่งอาจเป็น ‘queued’, ‘processing’, ‘done’ หรือ ‘error’
วิธีปฏิบัติที่ดีที่สุดคือการใช้กลไกการโพลล์ที่ตรวจสอบสถานะทุกๆ สองสามวินาที
 คุณควรทำการโพลล์ต่อไปจนกว่าสถานะจะเปลี่ยนเป็น ‘done’ หรือ ‘error’
 วิธีนี้จะช่วยป้องกันไม่ให้แอปพลิเคชันของคุณรออย่างไม่มีกำหนด และช่วยให้คุณจัดการกับความล้มเหลวในการแปลที่อาจเกิดขึ้นได้อย่างราบรื่น

def check_translation_status(document_id):
    """Polls the API to check the status of the translation."""
    while True:
        print("Checking translation status...")
        try:
            response = requests.get(f"{BASE_URL}/documents/{document_id}", headers=HEADERS)
            response.raise_for_status()
            
            status = response.json().get("status")
            print(f"Current status: {status}")
            
            if status == "done":
                print("Translation is complete.")
                return True
            elif status == "error":
                print("An error occurred during translation.")
                return False
            
            # Wait for 5 seconds before checking again
            time.sleep(5)
        except requests.exceptions.RequestException as e:
            print(f"An error occurred while checking status: {e}")
            return False

ขั้นตอนที่ 4: การดาวน์โหลดเอกสารที่แปลแล้ว
เมื่อสถานะเป็น ‘done’ เอกสารที่แปลแล้วก็พร้อมสำหรับการดาวน์โหลด
 คุณสามารถดึงข้อมูลได้โดยการส่งคำขอ `GET` ไปยังจุดสิ้นสุด `/v2/documents/{documentId}/download`
 จุดสิ้นสุดนี้จะสตรีมข้อมูลไฟล์ไบนารี ดังนั้นคุณต้องจัดการเนื้อหาการตอบกลับเป็นสตรีมไบต์ดิบและเขียนลงในไฟล์ใหม่
ขั้นตอนสุดท้ายนี้เสร็จสมบูรณ์เวิร์กโฟลว์การแปล ทำให้คุณได้รับเอกสารที่แปลอย่างสมบูรณ์และจัดรูปแบบได้อย่างสมบูรณ์แบบ
 โค้ดต่อไปนี้สาธิตวิธีการดาวน์โหลดไฟล์และบันทึกไว้ในเครื่อง
 มีการรวมการจัดการข้อผิดพลาดที่เหมาะสมเพื่อจัดการปัญหาที่อาจเกิดขึ้นระหว่างกระบวนการดาวน์โหลด เพื่อให้มั่นใจถึงการใช้งานที่แข็งแกร่ง

def download_translated_document(document_id, target_path):
    """Downloads the translated document."""
    print(f"Downloading translated document to {target_path}...")
    try:
        response = requests.get(f"{BASE_URL}/documents/{document_id}/download", headers=HEADERS, stream=True)
        response.raise_for_status()
        
        with open(target_path, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)
        
        print("Download complete.")
    except requests.exceptions.RequestException as e:
        print(f"An error occurred during download: {e}")

# Main execution logic
if __name__ == "__main__":
    doc_id = upload_document(SOURCE_FILE_PATH)
    if doc_id:
        if check_translation_status(doc_id):
            download_translated_document(doc_id, TARGET_FILE_PATH)

ข้อพิจารณาสำคัญสำหรับการแปลภาษาอังกฤษเป็นภาษาโปรตุเกส
การแปลจากภาษาอังกฤษเป็นภาษาโปรตุเกสเกี่ยวข้องกับมากกว่าแค่การแปลงคำต่อคำโดยตรง
 ภาษามีความแตกต่างทางไวยากรณ์และวัฒนธรรมเฉพาะที่การแปลที่มีคุณภาพสูงต้องเคารพเพื่อให้ฟังดูเป็นธรรมชาติและเป็นมืออาชีพ
 เมื่อใช้ Document Translation API สิ่งสำคัญคือต้องตระหนักถึงวิธีการจัดการรายละเอียดทางภาษาเหล่านี้เพื่อให้แน่ใจว่าได้ผลลัพธ์ที่ดีที่สุด
การจัดการเครื่องหมายกำกับเสียงและอักขระพิเศษ
ดังที่กล่าวไว้ก่อนหน้านี้ ภาษาโปรตุเกสใช้เครื่องหมายกำกับเสียงจำนวนมาก ซึ่งจำเป็นต่อการสะกดและการออกเสียงที่ถูกต้อง
 บริการแปลที่เชื่อถือได้จะต้องจัดการชุดอักขระ UTF-8 เต็มรูปแบบเพื่อสร้างอักขระเหล่านี้ขึ้นมาใหม่ได้อย่างไม่มีที่ติ
 ซึ่งรวมถึงอักขระ เช่น `ç`, `ã`, `õ`, `á`, `é`, `ê` และ `ô` ซึ่งเป็นพื้นฐานของภาษาเขียนและต้องได้รับการรักษาไว้อย่างแม่นยำในเอกสารฉบับสุดท้าย
Doctranslate API ถูกสร้างขึ้นเพื่อจัดการความซับซ้อนเหล่านี้โดยอัตโนมัติ
 มันช่วยให้มั่นใจว่าอักขระพิเศษทั้งหมดได้รับการเข้ารหัสและแสดงผลอย่างถูกต้องในไฟล์เอาต์พุต โดยไม่คำนึงถึงรูปแบบเอกสาร
 ความใส่ใจในรายละเอียดนี้ช่วยขจัดความเสี่ยงที่ข้อความจะเสียหาย และรับประกันการแปลระดับมืออาชีพที่ใช้งานได้ทันที
ข้อตกลงเรื่องเพศและจำนวนตามบริบท
ภาษาโปรตุเกสเป็นภาษาที่มีเพศ หมายถึงคำนามเป็นได้ทั้งเพศชายหรือเพศหญิง และคำคุณศัพท์ต้องสอดคล้องกับคำนามเหล่านั้นทั้งในด้านเพศและจำนวน
 สิ่งนี้เป็นความท้าทายที่สำคัญสำหรับระบบการแปลอัตโนมัติ เนื่องจากภาษาอังกฤษมักจะขาดเครื่องหมายแสดงเพศที่ชัดเจน
 ตัวอย่างเช่น ‘a big house’ กลายเป็น ‘uma casa grande’ (เพศหญิง) ในขณะที่ ‘a big car’ กลายเป็น ‘um carro grande’ (เพศชาย)
เครื่องมือแปลที่ซับซ้อนต้องใช้เบาะแสตามบริบทเพื่อกำหนดเพศที่ถูกต้องและใช้ตัวปรับแต่งที่เหมาะสม
 โมเดลการแปลด้วยเครื่องประสาทสมัยใหม่ เช่น โมเดลที่ใช้โดย Doctranslate ได้รับการฝึกฝนบนชุดข้อมูลขนาดใหญ่เพื่อทำความเข้าใจรูปแบบเหล่านี้
 สิ่งนี้ช่วยให้ API สร้างการแปลที่ถูกต้องตามหลักไวยากรณ์และเป็นธรรมชาติซึ่งเคารพกฎพื้นฐานของภาษาโปรตุเกสเหล่านี้
การสำรวจภาษาถิ่นโปรตุเกส (BR เทียบกับ PT)
มีภาษาถิ่นโปรตุเกสหลักสองภาษา: โปรตุเกสแบบบราซิล (PT-BR) และโปรตุเกสแบบยุโรป (PT-PT)
 แม้ว่าจะเข้าใจกันได้ แต่ก็มีความแตกต่างที่น่าสังเกตในด้านคำศัพท์ ไวยากรณ์ และความเป็นทางการ
 ตัวอย่างเช่น ‘train’ คือ ‘trem’ ในบราซิล แต่เป็น ‘comboio’ ในโปรตุเกส และการใช้คำสรรพนาม เช่น ‘você’ และ ‘tu’ ก็แตกต่างกันอย่างมาก
เพื่อให้แน่ใจว่าเนื้อหาที่แปลของคุณเข้าถึงกลุ่มเป้าหมายของคุณ การเลือกภาษาถิ่นที่ถูกต้องจึงเป็นสิ่งสำคัญ
 Doctranslate API รองรับ locale-specific translations, allowing you to specify `PT-BR` or `PT-PT` as your target.
 คุณสมบัติอันทรงพลังนี้ทำให้มั่นใจได้ว่าเอกสารของคุณใช้คำศัพท์และโทนเสียงที่เหมาะสมสำหรับผู้อ่านที่คุณตั้งใจไว้ ไม่ว่าพวกเขาจะอยู่ในบราซิล โปรตุเกส หรือภูมิภาคอื่นที่พูดภาษาโปรตุเกสก็ตาม
สรุป: ปรับปรุงเวิร์กโฟลว์การแปลของคุณ
การแปลเอกสารอัตโนมัติจากภาษาอังกฤษเป็นภาษาโปรตุเกสเป็นงานที่ซับซ้อนซึ่งเต็มไปด้วยความท้าทายทางเทคนิค
 ตั้งแต่การรักษารูปแบบไฟล์ที่ซับซ้อนไปจนถึงการจัดการความแตกต่างทางภาษาของภาษาโปรตุเกส การนำไปใช้ที่ประสบความสำเร็จต้องใช้โซลูชันเฉพาะทางและแข็งแกร่ง
 การพยายามสร้างฟังก์ชันนี้ตั้งแต่เริ่มต้นมักจะใช้งานไม่ได้จริง ใช้ทรัพยากรการพัฒนาที่มีค่า และนำไปสู่ผลลัพธ์ที่ไม่เหมาะสม
The Doctranslate Document Translation API นำเสนอโซลูชันที่ครอบคลุมและเป็นมิตรกับนักพัฒนาสำหรับปัญหานี้
 ด้วยการแยกความซับซ้อนของการแยกวิเคราะห์ไฟล์ การเข้ารหัสอักขระ และการรักษารูปแบบออกไป ทำให้คุณสามารถรวมการแปลที่รวดเร็ว แม่นยำ และเชื่อถือได้ด้วยโค้ดเพียงไม่กี่บรรทัด
 สิ่งนี้ช่วยให้คุณขยายการเข้าถึงทั่วโลกของแอปพลิเคชันของคุณได้อย่างมีประสิทธิภาพและประสิทธิผล โดยส่งมอบเนื้อหาที่แปลเป็นภาษาท้องถิ่นคุณภาพสูงให้กับผู้ใช้ของคุณ สำหรับการกำหนดค่าขั้นสูงเพิ่มเติมและรายการรูปแบบไฟล์ที่รองรับทั้งหมด โปรดดูเอกสารประกอบ API อย่างเป็นทางการของเรา