Building Voice AI Applications with Chinese Models: ASR, TTS, and Voice Cloning (2026)

August 14, 2026 · 16 min read

Voice AI is transforming how users interact with applications. Chinese AI providers now offer speech recognition, text-to-speech, and voice cloning at prices 5-10× lower than Western alternatives. This guide covers building production voice applications using models available through TokenEase.

The Voice AI Stack

1. Speech-to-Text (ASR)

import requests
import base64

TOKEN = "your_tokenease_api_key"
BASE_URL = "https://tokenease.io/v1"

def speech_to_text(audio_path, model="paraformer", language="zh"):
    """Convert audio to text"""
    
    with open(audio_path, "rb") as f:
        audio_data = base64.b64encode(f.read()).decode()
    
    response = requests.post(
        f"{BASE_URL}/audio/transcriptions",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={
            "model": model,
            "file": audio_data,
            "language": language,
            "response_format": "json"
        }
    )
    
    return response.json()

# Transcribe a meeting recording
transcript = speech_to_text("meeting_recording.wav", language="zh")
print(transcript["text"])

# With timestamps for subtitles
transcript_with_timestamps = speech_to_text(
    "podcast.mp3",
    language="en",
    response_format="verbose_json"
)
for segment in transcript_with_timestamps["segments"]:
    print(f"[{segment['start']:.2f} - {segment['end']:.2f}] {segment['text']}")

2. Text-to-Speech (TTS)

def text_to_speech(text, voice="zh-CN-Xiaoxiao", model="doubao-tts", output_path="output.mp3"):
    """Convert text to speech"""
    
    response = requests.post(
        f"{BASE_URL}/audio/speech",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={
            "model": model,
            "input": text,
            "voice": voice,
            "response_format": "mp3",
            "speed": 1.0
        }
    )
    
    with open(output_path, "wb") as f:
        f.write(response.content)
    
    return output_path

# Generate audiobook chapter
text = """人工智能正在深刻改变我们的世界。从自动驾驶到医疗诊断，AI技术正在各个领域展现出巨大的潜力。"""

text_to_speech(text, voice="zh-CN-Yunxi", output_path="chapter_1.mp3")

# English TTS
english_text = "Artificial intelligence is transforming how we work and live."
text_to_speech(english_text, voice="en-US-Aria", model="doubao-tts", output_path="english.mp3")

3. Voice Cloning

def clone_voice(reference_audio_path, text, output_path="cloned.mp3"):
    """Clone a voice from reference audio"""
    
    with open(reference_audio_path, "rb") as f:
        reference_audio = base64.b64encode(f.read()).decode()
    
    response = requests.post(
        f"{BASE_URL}/audio/speech",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={
            "model": "speech-02",
            "input": text,
            "voice": reference_audio,  # Base64-encoded reference
            "response_format": "mp3"
        }
    )
    
    with open(output_path, "wb") as f:
        f.write(response.content)
    
    return output_path

# Clone your voice for personalized content
clone_voice(
    "my_voice_sample.wav",  # 10-30 seconds of clear speech
    "Welcome to our platform. I'm your personal AI assistant.",
    "welcome_message.mp3"
)

4. Real-time Voice Chat

import pyaudio
import wave
import threading

class RealtimeVoiceChat:
    def __init__(self):
        self.audio = pyaudio.PyAudio()
        self.is_recording = False
        self.frames = []
    
    def start_recording(self):
        """Start recording from microphone"""
        self.is_recording = True
        self.frames = []
        
        def record():
            stream = self.audio.open(
                format=pyaudio.paInt16,
                channels=1,
                rate=16000,
                input=True,
                frames_per_buffer=1024
            )
            
            while self.is_recording:
                data = stream.read(1024)
                self.frames.append(data)
            
            stream.stop_stream()
            stream.close()
        
        self.record_thread = threading.Thread(target=record)
        self.record_thread.start()
    
    def stop_recording(self):
        """Stop and process recording"""
        self.is_recording = False
        self.record_thread.join()
        
        # Save to temp file
        with wave.open("temp_input.wav", "wb") as wf:
            wf.setnchannels(1)
            wf.setsampwidth(self.audio.get_sample_size(pyaudio.paInt16))
            wf.setframerate(16000)
            wf.writeframes(b"".join(self.frames))
        
        # Transcribe
        transcript = speech_to_text("temp_input.wav")
        user_text = transcript["text"]
        
        # Get AI response
        ai_response = chat_with_ai(user_text)
        
        # Speak response
        text_to_speech(ai_response, output_path="temp_output.mp3")
        
        return user_text, ai_response
    
    def chat_with_ai(self, text):
        """Send text to AI and get response"""
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers={"Authorization": f"Bearer {TOKEN}"},
            json={
                "model": "deepseek-v4",
                "messages": [{"role": "user", "content": text}],
                "max_tokens": 500
            }
        )
        return response.json()["choices"][0]["message"]["content"]

# Usage
voice_chat = RealtimeVoiceChat()
voice_chat.start_recording()
# ... user speaks ...
voice_chat.stop_recording()  # Returns (user_text, ai_response)

5. Voice AI for Accessibility

def create_accessible_content(text_content, output_dir="accessible"):
    """Create audio version of written content"""
    
    import os
    os.makedirs(output_dir, exist_ok=True)
    
    # Split into paragraphs
    paragraphs = text_content.split("\n\n")
    
    audio_files = []
    for i, paragraph in enumerate(paragraphs):
        if paragraph.strip():
            output_path = f"{output_dir}/paragraph_{i+1:03d}.mp3"
            text_to_speech(paragraph, output_path=output_path)
            audio_files.append(output_path)
    
    # Generate M3U playlist
    with open(f"{output_dir}/playlist.m3u", "w") as f:
        for audio_file in audio_files:
            f.write(f"{audio_file}\n")
    
    return audio_files

# Convert article to audiobook
article = open("article.txt").read()
audio_files = create_accessible_content(article)

Cost Comparison: 1 Hour of Audio

Supported Languages

• Chinese: Mandarin (zh), Cantonese (yue)
• English: US, UK, AU accents
• Asian: Japanese, Korean, Thai, Vietnamese
• European: Spanish, French, German, Italian, Portuguese, Russian

Next Steps

1. Test ASR quality with your target audio samples
2. Evaluate TTS voices for your brand persona
3. Implement voice cloning for personalized experiences
4. Build real-time voice chat for hands-free interaction
5. Get your TokenEase API key for voice APIs

For related guides, see real-time streaming APIs and chatbot development.

Last updated: August 2026. Voice model quality varies by language.