API สำหรับแปล PDF ภาษาสเปนเป็นภาษาเวียดนาม: การผสานรวมที่รวดเร็วและง่ายดาย

เหตุใดการแปล PDF โดยใช้โปรแกรมจึงเป็นความท้าทายที่สำคัญ

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

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

นอกจากนี้ การจัดการองค์ประกอบที่ฝังอยู่ เช่น ตาราง แผนภูมิ และกราฟ ยังเพิ่มความซับซ้อนอีกชั้นหนึ่ง
องค์ประกอบเหล่านี้จะต้องถูกระบุ เนื้อหาข้อความจะต้องถูกแปล และจากนั้นจะต้องถูกสร้างขึ้นใหม่ในเอกสารเป้าหมายได้อย่างสมบูรณ์
การเข้ารหัสอักขระยังเป็นปัญหาสำคัญ โดยเฉพาะอย่างยิ่งเมื่อต้องรับมือกับเครื่องหมายเน้นเสียงของภาษาสเปน (เช่น ñ, á, é) และเครื่องหมายเสริมสัทอักษรที่ซับซ้อนของภาษาเวียดนาม (เช่น ă, ê, ô, ư)
การจัดการการเข้ารหัสผิดพลาดอาจนำไปสู่ข้อความที่ผิดเพี้ยน ทำให้เอกสารสุดท้ายอ่านไม่ออกและดูไม่เป็นมืออาชีพโดยสิ้นเชิง

ขอแนะนำ Doctranslate API: โซลูชันที่ให้ความสำคัญกับนักพัฒนาเป็นอันดับแรก

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

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

การโต้ตอบกับ API จะจัดการผ่านคำขอ HTTP มาตรฐาน โดยมีการตอบสนองเป็นรูปแบบ JSON ที่สะอาด
สิ่งนี้ทำให้การผสานรวมทำได้ตรงไปตรงมาสำหรับภาษาโปรแกรมสมัยใหม่ใดๆ ตั้งแต่ Python และ Node.js ไปจนถึง Java และ C#
นักพัฒนาสามารถมุ่งเน้นไปที่ตรรกะหลักของแอปพลิเคชันแทนที่จะจมอยู่กับรายละเอียดที่ซับซ้อนของการจัดการ PDF
การออกแบบที่เน้นนักพัฒนานี้ช่วยให้มั่นใจได้ว่ากระบวนการผสานรวมจะรวดเร็ว ประหยัดเวลาและทรัพยากรอันมีค่า

คู่มือทีละขั้นตอน: การผสานรวม API สำหรับการแปล PDF จากภาษาสเปนเป็นภาษาเวียดนาม

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

การตั้งค่าสภาพแวดล้อมของคุณ

ก่อนที่จะทำการเรียก API ใดๆ คุณต้องแน่ใจว่าสภาพแวดล้อมการพัฒนาของคุณพร้อมที่จะจัดการคำขอ HTTP และการอัปโหลดไฟล์แบบหลายส่วน
สำหรับนักพัฒนา Python ไลบรารี `requests` เป็นตัวเลือกมาตรฐานสำหรับความเรียบง่ายและพลังในการจัดการการสื่อสาร HTTP
คุณสามารถติดตั้งได้อย่างง่ายดายโดยใช้ pip: `pip install requests`
สำหรับนักพัฒนา Node.js นั้น `axios` เป็นไคลเอนต์ HTTP ที่ใช้คำสัญญาที่ได้รับความนิยม และ `form-data` มีความสำคัญอย่างยิ่งสำหรับการสร้างคำขออัปโหลดไฟล์
สิ่งเหล่านี้สามารถติดตั้งได้ผ่าน npm: `npm install axios form-data`

การรับรองความถูกต้อง: การรับคีย์ API ของคุณ

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

ขั้นตอนที่ 1: การอัปโหลด PDF ภาษาสเปนของคุณ

ขั้นตอนแรกในขั้นตอนการทำงานของการแปลคือการอัปโหลดเอกสาร PDF ภาษาสเปนต้นฉบับของคุณไปยังเซิร์ฟเวอร์ Doctranslate
ทำได้โดยการส่งคำขอ `POST` ไปยังเอนด์พอยต์ `/v2/document/upload`
คำขอจะต้องจัดรูปแบบเป็น `multipart/form-data` และรวมไฟล์นั้นเองภายใต้พารามิเตอร์ `file`
การอัปโหลดที่สำเร็จจะส่งกลับการตอบสนอง JSON ที่มี `document_id` ที่ไม่ซ้ำกัน ซึ่งคุณจะใช้ในขั้นตอนต่อๆ ไป

ขั้นตอนที่ 2: การเริ่มการแปลเป็นภาษาเวียดนาม

เมื่อคุณมี `document_id` แล้ว คุณสามารถเริ่มกระบวนการแปลได้
คุณจะส่งคำขอ `POST` ไปยังเอนด์พอยต์ `/v2/translate/document` พร้อมเพย์โหลด JSON
เพย์โหลดนี้จะต้องมี `document_id` จากขั้นตอนก่อนหน้า, `source_lang` ตั้งค่าเป็น `es` สำหรับภาษาสเปน และ `target_lang` ตั้งค่าเป็น `vi` สำหรับภาษาเวียดนาม
จากนั้น API จะส่งกลับ `translation_id` ซึ่งทำหน้าที่เป็นตัวระบุเฉพาะสำหรับงานแปลนี้

ขั้นตอนที่ 3: การตรวจสอบสถานะการแปล

การแปลเอกสารเป็นกระบวนการที่ไม่ประสานเวลา ซึ่งหมายความว่าทำงานอยู่เบื้องหลัง
คุณจะต้องตรวจสอบสถานะของงานเป็นระยะจนกว่าจะเสร็จสมบูรณ์
ทำได้โดยการสร้างคำขอ `GET` ไปยังเอนด์พอยต์ `/v2/translate/document/status` โดยรวม `translation_id` เป็นพารามิเตอร์คิวรี
API จะตอบกลับด้วยสถานะปัจจุบัน ซึ่งอาจเป็น `processing`, `done` หรือ `error`
คุณควรสำรวจเอนด์พอยต์นี้ในช่วงเวลาที่เหมาะสมจนกว่าสถานะจะเปลี่ยนเป็น `done`

ขั้นตอนที่ 4: การดาวน์โหลด PDF ที่แปลแล้ว

เมื่อสถานะเป็น `done` PDF ภาษาเวียดนามที่แปลเสร็จสมบูรณ์ก็พร้อมสำหรับการดาวน์โหลด
คุณสามารถดึงไฟล์ได้โดยการสร้างคำขอ `GET` ไปยังเอนด์พอยต์ `/v2/translate/document/download` โดยใช้ `translation_id` เป็นพารามิเตอร์คิวรีอีกครั้ง
การตอบสนองของ API จะเป็นข้อมูลไบนารีของไฟล์ PDF ที่แปลแล้ว
โค้ดแอปพลิเคชันของคุณควรเตรียมพร้อมที่จะจัดการสตรีมไบนารีนี้และบันทึกเป็นไฟล์ `.pdf` ใหม่ พลังที่แท้จริงของ API นี้คือความสามารถในการประมวลผลเอกสารที่ซับซ้อนได้อย่างน่าเชื่อถือ สำหรับนักพัฒนาที่ต้องการโซลูชันเพื่อ แปลเอกสารพร้อมทั้งรักษารูปแบบและตารางไว้ The Doctranslate API มีเวิร์กโฟลว์อัตโนมัติและมีประสิทธิภาพสูง

ตัวอย่างการผสานรวม Python

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

import requests
import time
import os

API_KEY = os.getenv('DOCTRANSLATE_API_KEY', 'YOUR_API_KEY')
API_URL = 'https://developer.doctranslate.io/v2'
FILE_PATH = 'path/to/your/document.pdf'

def translate_spanish_to_vietnamese_pdf(file_path):
    headers = {'Authorization': f'Bearer {API_KEY}'}

    # Step 1: Upload the document
    print("Step 1: Uploading document...")
    with open(file_path, 'rb') as f:
        files = {'file': (os.path.basename(file_path), f, 'application/pdf')}
        response = requests.post(f'{API_URL}/document/upload', headers=headers, files=files)

    if response.status_code != 200:
        print(f"Error uploading file: {response.text}")
        return

    document_id = response.json().get('document_id')
    print(f"Document uploaded successfully. Document ID: {document_id}")

    # Step 2: Initiate translation
    print("
Step 2: Initiating translation to Vietnamese...")
    payload = {
        'document_id': document_id,
        'source_lang': 'es',
        'target_lang': 'vi'
    }
    response = requests.post(f'{API_URL}/translate/document', headers=headers, json=payload)

    if response.status_code != 200:
        print(f"Error initiating translation: {response.text}")
        return

    translation_id = response.json().get('translation_id')
    print(f"Translation initiated. Translation ID: {translation_id}")

    # Step 3: Check translation status
    print("
Step 3: Checking translation status...")
    while True:
        status_response = requests.get(f'{API_URL}/translate/document/status?translation_id={translation_id}', headers=headers)
        status = status_response.json().get('status')
        print(f"Current status: {status}")
        if status == 'done':
            break
        elif status == 'error':
            print("Translation failed.")
            return
        time.sleep(5) # Poll every 5 seconds

    # Step 4: Download the translated document
    print("
Step 4: Downloading translated document...")
    download_response = requests.get(f'{API_URL}/translate/document/download?translation_id={translation_id}', headers=headers)

    if download_response.status_code == 200:
        translated_file_path = 'translated_document_vi.pdf'
        with open(translated_file_path, 'wb') as f:
            f.write(download_response.content)
        print(f"Translated document saved to {translated_file_path}")
    else:
        print(f"Error downloading file: {download_response.text}")

if __name__ == '__main__':
    if API_KEY == 'YOUR_API_KEY':
        print("Please set your DOCTRANSLATE_API_KEY.")
    elif not os.path.exists(FILE_PATH):
        print(f"File not found at: {FILE_PATH}")
    else:
        translate_spanish_to_vietnamese_pdf(FILE_PATH)

ตัวอย่างการผสานรวม Node.js
สำหรับนักพัฒนา JavaScript นี่คือตัวอย่างที่เทียบเท่าโดยใช้ Node.js กับ `axios` และ `form-data` 
สคริปต์นี้เป็นไปตามตรรกะการสำรวจแบบไม่ประสานเวลาเดียวกันเพื่อจัดการกระบวนการแปลอย่างมีประสิทธิภาพ 
อย่าลืมตั้งค่าคีย์ API และเส้นทางไฟล์ของคุณก่อนที่จะรันสคริปต์
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');

const API_KEY = process.env.DOCTRANSLATE_API_KEY || 'YOUR_API_KEY';
const API_URL = 'https://developer.doctranslate.io/v2';
const FILE_PATH = 'path/to/your/document.pdf';

const headers = {
    'Authorization': `Bearer ${API_KEY}`,
};

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function translatePdf() {
    if (API_KEY === 'YOUR_API_KEY') {
        console.error('Please set your DOCTRANSLATE_API_KEY.');
        return;
    }
    if (!fs.existsSync(FILE_PATH)) {
        console.error(`File not found at: ${FILE_PATH}`);
        return;
    }

    try {
        // Step 1: Upload the document
        console.log('Step 1: Uploading document...');
        const form = new FormData();
        form.append('file', fs.createReadStream(FILE_PATH));
        const uploadResponse = await axios.post(`${API_URL}/document/upload`, form, {
            headers: { ...headers, ...form.getHeaders() },
        });
        const { document_id } = uploadResponse.data;
        console.log(`Document uploaded successfully. Document ID: ${document_id}`);

        // Step 2: Initiate translation
        console.log('
Step 2: Initiating translation to Vietnamese...');
        const translatePayload = {
            document_id,
            source_lang: 'es',
            target_lang: 'vi',
        };
        const translateResponse = await axios.post(`${API_URL}/translate/document`, translatePayload, { headers });
        const { translation_id } = translateResponse.data;
        console.log(`Translation initiated. Translation ID: ${translation_id}`);

        // Step 3: Check translation status
        console.log('
Step 3: Checking translation status...');
        let status = '';
        while (status !== 'done') {
            const statusResponse = await axios.get(`${API_URL}/translate/document/status?translation_id=${translation_id}`, { headers });
            status = statusResponse.data.status;
            console.log(`Current status: ${status}`);
            if (status === 'error') {
                throw new Error('Translation failed.');
            }
            if (status !== 'done') {
                await sleep(5000); // Poll every 5 seconds
            }
        }

        // Step 4: Download the translated document
        console.log('
Step 4: Downloading translated document...');
        const downloadResponse = await axios.get(`${API_URL}/translate/document/download?translation_id=${translation_id}`, {
            headers,
            responseType: 'stream',
        });
        const translatedFilePath = 'translated_document_vi.pdf';
        const writer = fs.createWriteStream(translatedFilePath);
        downloadResponse.data.pipe(writer);

        return new Promise((resolve, reject) => {
            writer.on('finish', () => {
                console.log(`Translated document saved to ${translatedFilePath}`);
                resolve();
            });
            writer.on('error', reject);
        });

    } catch (error) {
        console.error('An error occurred:', error.response ? error.response.data : error.message);
    }
}

translatePdf();

ข้อพิจารณาที่สำคัญสำหรับลักษณะเฉพาะของภาษาเวียดนาม
การแปลเนื้อหาเป็นภาษาเวียดนามนำเสนอความท้าทายทางภาษาและเทคนิคที่เป็นเอกลักษณ์ ซึ่งต้องได้รับการจัดการอย่างถูกต้องเพื่อให้ได้ผลลัพธ์ที่มีคุณภาพสูง 
The Doctranslate API ได้รับการออกแบบทางวิศวกรรมมาโดยเฉพาะเพื่อจัดการกับความซับซ้อนเหล่านี้ เพื่อให้มั่นใจว่าผลลัพธ์สุดท้ายทั้งถูกต้องแม่นยำและถูกต้องทางสายตา 
นักพัฒนาควรตระหนักถึงปัญหาเหล่านี้เพื่อชื่นชมพลังที่ซ่อนอยู่ของกลไกการแปล
การจัดการเครื่องหมายเสริมสัทอักษรและวรรณยุกต์
ภาษาเวียดนามเป็นภาษาที่มีวรรณยุกต์ซึ่งใช้ระบบเครื่องหมายเสริมสัทอักษรที่ซับซ้อนเพื่อแสดงทั้งเสียงสระและวรรณยุกต์ 
อักขระตัวเดียวสามารถมีเครื่องหมายหลายตัวได้ เช่น ในตัวอักษร ‘ệ’ หรือ ‘ậ’ 
ระบบการแปลมาตรฐานและตัวแสดงผลแบบอักษรจำนวนมากประสบปัญหาในการประมวลผลอักขระผสมเหล่านี้อย่างถูกต้อง 
กลไกการแปลขั้นสูงและเทคโนโลยีการสร้างเอกสารใหม่ของ Doctranslate API ได้รับการปรับแต่งมาอย่างดีเพื่อจัดการกับกรณีเหล่านี้ ทำให้มั่นใจได้ว่าเครื่องหมายเสริมสัทอักษรทั้งหมดจะถูกเก็บรักษาไว้และแสดงผลได้อย่างแม่นยำใน PDF สุดท้าย
การรับรองการเข้ารหัส UTF-8
การเข้ารหัสอักขระที่เหมาะสมเป็นสิ่งที่หลีกเลี่ยงไม่ได้สำหรับแอปพลิเคชันหลายภาษา โดยเฉพาะอย่างยิ่งที่เกี่ยวข้องกับภาษาเวียดนาม 
UTF-8 เป็นมาตรฐานสากลที่สามารถแสดงอักขระทุกตัวในตัวอักษรเวียดนามได้อย่างถูกต้อง 
The Doctranslate API ทำงานทั้งหมดภายในสภาพแวดล้อม UTF-8 ตั้งแต่การดึงข้อความไปจนถึงการแปลและการสร้างเอกสารขั้นสุดท้าย 
สิ่งนี้ช่วยขจัดความเสี่ยงของ `mojibake` หรือข้อความที่ผิดเพี้ยน ทำให้นักพัฒนามีความสบายใจว่าข้อมูลข้อความทั้งหมดได้รับการจัดการอย่างครบถ้วนตลอดขั้นตอนการทำงาน
รูปร่างแบบอักษรและการแสดงผล
ปัญหาทั่วไปเมื่อแสดงข้อความที่แปลคือรูปร่างแบบอักษรหายไป ซึ่งปรากฏเป็นกล่องว่างเปล่า (มักเรียกว่า ‘เต้าหู้’) 
สิ่งนี้เกิดขึ้นเมื่อแบบอักษรที่ฝังอยู่ใน PDF ภาษาสเปนต้นฉบับไม่มีอักขระที่จำเป็นสำหรับภาษาเวียดนาม 
The Doctranslate API จัดการปัญหานี้อย่างชาญฉลาดโดยการดำเนินการแทนที่แบบอักษรอย่างชาญฉลาด 
โดยจะแทนที่หรือฝังแบบอักษรที่เข้ากันได้โดยอัตโนมัติซึ่งมีรูปร่างอักขระเวียดนามที่จำเป็น ทำให้มั่นใจได้ว่าเอกสารที่แปลแล้วสามารถอ่านได้อย่างสมบูรณ์และรักษาลักษณะที่เป็นมืออาชีพ
บทสรุปและขั้นตอนถัดไป
การผสานรวม API สำหรับการแปล PDF จากภาษาสเปนเป็นภาษาเวียดนามสามารถปรับปรุงประสิทธิภาพได้อย่างมากและเปิดโอกาสใหม่สำหรับการสื่อสารข้ามตลาด 
The Doctranslate API มอบโซลูชันที่ทรงพลัง เชื่อถือได้ และเป็นมิตรกับนักพัฒนา ซึ่งจัดการกับความซับซ้อนของการแปล PDF ได้อย่างเชี่ยวชาญ 
ด้วยการรักษารูปแบบเอกสารและการจัดการความแตกต่างของภาษาเวียดนาม ทำให้คุณสามารถทำให้กระบวนการที่เคยต้องทำด้วยตนเองและมีแนวโน้มที่จะเกิดข้อผิดพลาดกลายเป็นระบบอัตโนมัติได้
คู่มือนี้ได้แนะนำคุณตลอดการผสานรวมที่สมบูรณ์ ตั้งแต่การตั้งค่าไปจนถึงการดาวน์โหลดไฟล์ที่แปลขั้นสุดท้าย 
กระบวนการสี่ขั้นตอนที่ไม่ประสานเวลาที่เรียบง่าย—อัปโหลด แปล ตรวจสอบสถานะ และดาวน์โหลด—สามารถนำไปใช้ได้อย่างง่ายดายโดยใช้ไลบรารีมาตรฐานในภาษาโปรแกรมใดก็ได้ 
สิ่งนี้ช่วยให้นักพัฒนาสามารถสร้างขั้นตอนการทำงานของการแปลอัตโนมัติที่ซับซ้อนลงในแอปพลิเคชันของตนได้โดยตรง 
เราสนับสนุนให้คุณสำรวจความสามารถทั้งหมดและเริ่มต้นสร้างได้ตั้งแต่วันนี้
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับคุณสมบัติขั้นสูง เช่น อภิธานศัพท์แบบกำหนดเอง การควบคุมน้ำเสียง หรือการแปลรูปแบบเอกสารอื่นๆ โปรดดูเอกสารประกอบ Doctranslate API อย่างเป็นทางการ 
เอกสารประกอบให้คำอธิบายเชิงลึกเกี่ยวกับเอนด์พอยต์และพารามิเตอร์ทั้งหมดที่มี 
เริ่มต้นการเดินทางผสานรวมของคุณตอนนี้เพื่อปลดล็อกการแปลเอกสารที่ราบรื่นและมีความแม่นยำสูง