Qwen-MT-Image can accurately translate text in images while preserving the original layout. The model also supports custom features such as domain hints, sensitive word filtering, and terminology intervention.
This document applies to the China (Beijing) region only. To use the model, you must use an API key from the China (Beijing) region.
Model overview
Examples
Source language: English |
Japanese |
Portuguese |
Arabic |
Supported languages
When you translate an image, at least one of the source or target languages must be Chinese or English. Direct translation between two non-Chinese or non-English languages, such as from Japanese to Korean, is not supported. If you are unsure of the source language, set source_lang to auto for automatic detection.
Language | Code | As source language | As target language |
Chinese | zh | ||
English | en | ||
Korean | ko | ||
Japanese | ja | ||
Russian | ru | ||
Spanish | es | ||
French | fr | ||
Portuguese | pt | ||
Italian | it | ||
Germany | de | ||
Vietnamese | vi | ||
Malay | ms | ||
Thai | th | ||
Indonesian | id | ||
Arabic | ar |
Model and pricing
Billing is based on the number of successfully translated images. The billing rules are as follows:
You are charged when a task succeeds (
task_statusisSUCCEEDED) and an image is generated.Special case: If no translatable text is found in the image, or if no text remains after subject identification is enabled, the task still succeeds and will incur fees. However, a message
No text detected for translationis returned.Requests that fail due to parameter errors, internal service errors, or network connectivity issues do not incur charges.
Model | Unit price | Rate limit (shared by Alibaba Cloud account and RAM users) | |
Task submission API RPS limit | Number of concurrent tasks | ||
qwen-mt-image | $0.000431/image | 1 | 2 |
HTTP
You must obtain an API key and set the API key as an environment variable.
POST https://dashscope.aliyuncs.com/api/v1/services/aigc/image2image/image-synthesis
Image translation uses the same API endpoint as image synthesis.
Because image translation takes time, the HTTP API uses an asynchronous mode. The process involves two steps:
Create a task and obtain a task ID: Send a request to create a task. The request returns a task ID (task_id).
Query the result using the task ID: Use the task_id to poll the task status until the task is complete and you retrieve the image URL.
Step 1: Create a task and get a task ID
After the task is created, use the returned
task_idto query the result. The task_id is valid for 24 hours. Do not create duplicate tasks. Use polling to retrieve the result.
Request parameters | Image translation |
Request headers | |
Content-Type The content type of the request. Set this parameter to | |
Authorization The identity authentication credentials for the request. This API uses an Model Studio API key for identity authentication. Example: Bearer sk-xxxx. | |
X-DashScope-Async The asynchronous processing configuration parameter. HTTP requests support only asynchronous processing. You must set this parameter to Important If this request header is missing, the error message "current user api does not support synchronous calls" is returned. | |
Request body | |
model The model name. Set it to | |
input The input parameter object. It contains the following fields: |
Response parameters | Successful responseSave the task_id to query the task status and result. Error responseThe task creation failed. For more information, see Error messages to resolve the issue. |
output Task output information. | |
request_id The unique request ID. You can use this ID to trace and troubleshoot issues. | |
message The detailed information about a failed request. This parameter is not returned if the request is successful. For more information, see Error messages. | |
code The error code for a failed request. This parameter is not returned if the request is successful. For more information, see Error messages. |
Step 2: Query the result using the task ID
GET https://dashscope.aliyuncs.com/api/v1/tasks/{task_id}
The model takes about 15 seconds to process. Use a polling mechanism with a reasonable query interval, such as 5 seconds, to retrieve the result.
The
task_idis valid for 24 hours. If the ID does not exist or has expired, the task status will beUNKNOWN.The
urlreturned for a successful task is valid for 24 hours. Download and save the image promptly.
Request parameters | Query task resultReplace |
Request headers | |
Authorization The identity authentication credentials for the request. This API uses an Model Studio API key for identity authentication. Example: Bearer sk-xxxx. | |
URL path parameters | |
task_id The task ID. |
Response parameters | Task successfulTask data, such as the task status and image URLs, is retained for only 24 hours and is automatically purged after this period. You must save the generated images promptly. Task failedIf a task fails, task_status is set to FAILED, and an error code and message are provided. For more information, see Error messages to resolve the issue. |
output Task output information. | |
usage Usage statistics for the task. Only successful tasks are counted. | |
request_id The unique request ID. You can use this ID to trace and troubleshoot issues. |
Code examples
In addition to cURL, this section provides code examples for other HTTP requests that use polling to obtain results.
Python
# The requests library is required.
import requests
import time
import json
import os
# If you have not configured the environment variable, replace the following line with: DASHSCOPE_API_KEY="sk-xxx"
DASHSCOPE_API_KEY = os.environ['DASHSCOPE_API_KEY']
POST_URL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/image2image/image-synthesis"
GET_URL_TEMPLATE = "https://dashscope.aliyuncs.com/api/v1/tasks/{}"
# Request headers
headers = {
"X-DashScope-Async": "enable",
"Authorization": f"Bearer {DASHSCOPE_API_KEY}",
"Content-Type": "application/json"
}
# Request data
data = {
"model": "qwen-mt-image",
"input": {
"image_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250916/arpjoo/p1000391.webp",
"source_lang": "en",
"target_lang": "ja"
}
}
def send_async_request():
"""
Sends an asynchronous POST request.
"""
print("Sending asynchronous POST request...")
response = requests.post(POST_URL, headers=headers, json=data)
if response.status_code == 200:
result = response.json()
print("Request successful. Response:")
print(json.dumps(result, indent=2, ensure_ascii=False))
# Extract the task_id
task_id = result.get("output", {}).get("task_id")
if task_id:
return task_id
else:
raise ValueError("task_id not found in the response")
else:
print(f"Request failed. Status code: {response.status_code}")
print(response.text)
raise Exception(f"POST request failed: {response.status_code}")
def poll_task_status(task_id, interval=5, max_attempts=10):
"""
Polls the task status.
:param task_id: The task ID.
:param interval: The polling interval in seconds.
:param max_attempts: The maximum number of polling attempts.
:return: The final task result.
"""
print(f"\nStart polling task status for task_id: {task_id}")
for attempt in range(1, max_attempts + 1):
print(f"Polling attempt {attempt}...")
# Construct the GET request URL
get_url = GET_URL_TEMPLATE.format(task_id)
# Send the GET request
response = requests.get(get_url, headers={"Authorization": f"Bearer {DASHSCOPE_API_KEY}"})
if response.status_code == 200:
result = response.json()
task_status = result.get("output", {}).get("task_status")
print(f"Current task status: {task_status}")
# If the task is complete or has failed, return the result
if task_status == "SUCCEEDED":
print("Task completed successfully")
return result
elif task_status == "FAILED":
print("Task failed")
return result
elif task_status == "PENDING" or task_status == "RUNNING":
# Continue polling
print(f"Task is still in progress. Polling again in {interval} seconds...")
time.sleep(interval)
else:
print(f"Unknown task status: {task_status}")
time.sleep(interval)
else:
print(f"Polling request failed. Status code: {response.status_code}")
print(response.text)
time.sleep(interval)
# Maximum polling attempts exceeded
raise TimeoutError("Polling timed out. The task did not complete within the expected time.")
def main():
task_id = send_async_request()
result = poll_task_status(task_id)
print("\nFinal task result:")
print(json.dumps(result, indent=2, ensure_ascii=False))
if result.get("output", {}).get("task_status") == "SUCCEEDED":
image_url = result.get("output", {}).get("image_url")
if image_url:
print(f"\nGenerated image URL: {image_url}")
if __name__ == "__main__":
main()
Java
// The Gson library is required.
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.nio.charset.StandardCharsets;
public class Main {
private static final String POST_URL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/image2image/image-synthesis";
private static final String GET_URL_TEMPLATE = "https://dashscope.aliyuncs.com/api/v1/tasks/";
private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
public static void main(String[] args) {
try {
// 1. Get the API key.
// If you have not configured the environment variable, replace the following line with: apiKey="sk-xxx"
String apiKey = System.getenv("DASHSCOPE_API_KEY");
if (apiKey == null || apiKey.isEmpty()) {
System.err.println("Please set the DASHSCOPE_API_KEY environment variable.");
return;
}
// 2. Send an asynchronous request.
String taskId = sendAsyncRequest(apiKey);
// 3. Poll the task status.
JsonObject result = pollTaskStatus(apiKey, taskId, 5, 10);
// 4. Print the final result.
System.out.println("\nFinal task result:");
System.out.println(gson.toJson(result));
// 5. If the task is successful, print the image URL.
String taskStatus = result.getAsJsonObject("output").get("task_status").getAsString();
if ("SUCCEEDED".equals(taskStatus)) {
String imageUrl = result.getAsJsonObject("output").get("image_url").getAsString();
System.out.println("\nGenerated image URL: " + imageUrl);
}
} catch (Exception e) {
System.err.println("An error occurred during execution: " + e.getMessage());
e.printStackTrace();
}
}
/**
* Sends an asynchronous POST request.
*/
private static String sendAsyncRequest(String apiKey) throws IOException {
System.out.println("Sending asynchronous POST request...");
// Build the request data.
Map<String, Object> data = new HashMap<>();
data.put("model", "qwen-mt-image");
Map<String, Object> input = new HashMap<>();
input.put("image_url", "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250916/arpjoo/p1000391.webp");
input.put("source_lang", "en");
input.put("target_lang", "ja");
data.put("input", input);
String jsonData = gson.toJson(data);
// Create a connection.
URL url = new URL(POST_URL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// Set the request headers.
connection.setRequestMethod("POST");
connection.setRequestProperty("X-DashScope-Async", "enable");
connection.setRequestProperty("Authorization", "Bearer " + apiKey);
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true);
// Send the request body.
try (OutputStream os = connection.getOutputStream()) {
byte[] inputBytes = jsonData.getBytes(StandardCharsets.UTF_8);
os.write(inputBytes, 0, inputBytes.length);
}
// Read the response.
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
StringBuilder response = new StringBuilder();
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
}
System.out.println("Request successful. Response:");
JsonObject jsonResponse = gson.fromJson(response.toString(), JsonObject.class);
System.out.println(gson.toJson(jsonResponse));
// Extract the task_id.
JsonObject result = gson.fromJson(response.toString(), JsonObject.class);
String taskId = result.getAsJsonObject("output").get("task_id").getAsString();
if (taskId != null && !taskId.isEmpty()) {
return taskId;
} else {
throw new RuntimeException("task_id not found in the response");
}
} else {
System.out.println("Request failed. Status code: " + responseCode);
StringBuilder errorResponse = new StringBuilder();
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
String responseLine;
while ((responseLine = br.readLine()) != null) {
errorResponse.append(responseLine.trim());
}
}
System.out.println(errorResponse.toString());
throw new RuntimeException("POST request failed: " + responseCode);
}
}
/**
* Polls the task status.
*
* @param apiKey The API key.
* @param taskId The task ID.
* @param interval The polling interval in seconds.
* @param maxAttempts The maximum number of polling attempts.
* @return The final task result.
*/
private static JsonObject pollTaskStatus(String apiKey, String taskId, int interval, int maxAttempts) throws IOException, InterruptedException {
System.out.println("\nStart polling task status for task_id: " + taskId);
for (int attempt = 1; attempt <= maxAttempts; attempt++) {
System.out.println("Polling attempt " + attempt + "...");
// Construct the GET request URL.
String getUrl = GET_URL_TEMPLATE + taskId;
// Create a connection.
URL url = new URL(getUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// Set the request headers.
connection.setRequestMethod("GET");
connection.setRequestProperty("Authorization", "Bearer " + apiKey);
// Read the response.
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
StringBuilder response = new StringBuilder();
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
}
JsonObject result = gson.fromJson(response.toString(), JsonObject.class);
String taskStatus = result.getAsJsonObject("output").get("task_status").getAsString();
System.out.println("Current task status: " + taskStatus);
// If the task is complete or has failed, return the result.
if ("SUCCEEDED".equals(taskStatus) || "FAILED".equals(taskStatus)) {
System.out.println("Task execution completed");
return result;
} else if ("PENDING".equals(taskStatus) || "RUNNING".equals(taskStatus)) {
// Continue polling.
System.out.println("Task is still in progress. Polling again in " + interval + " seconds...");
TimeUnit.SECONDS.sleep(interval);
} else {
System.out.println("Unknown task status: " + taskStatus);
TimeUnit.SECONDS.sleep(interval);
}
} else {
System.out.println("Polling request failed. Status code: " + responseCode);
StringBuilder errorResponse = new StringBuilder();
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
String responseLine;
while ((responseLine = br.readLine()) != null) {
errorResponse.append(responseLine.trim());
}
}
System.out.println(errorResponse.toString());
TimeUnit.SECONDS.sleep(interval);
}
}
// Maximum polling attempts exceeded.
throw new RuntimeException("Polling timed out. The task did not complete within the expected time.");
}
}
Response
Sending asynchronous POST request...
Request successful. Response:
{
"request_id": "ba607b73-8743-42cb-a605-c4db9688fc6e",
"output": {
"task_id": "9e82f1a9-12f4-4423-93e0-bb49xxxxxxxx",
"task_status": "PENDING"
}
}
Start polling task status for task_id: 9e82f1a9-12f4-4423-93e0-bb49xxxxxxxx
Polling attempt 1...
Current task status: RUNNING
Task is still in progress. Polling again in 5 seconds...
Polling attempt 2...
Current task status: RUNNING
Task is still in progress. Polling again in 5 seconds...
Polling attempt 3...
Current task status: SUCCEEDED
Task completed successfully
Final task result:
{
"request_id": "a1419de4-3f62-4582-8097-e6a66a843536",
"output": {
"task_id": "9e82f1a9-12f4-4423-93e0-bb49xxxxxxxx",
"task_status": "SUCCEEDED",
"submit_time": "2025-09-13 16:33:14.835",
"scheduled_time": "2025-09-13 16:33:14.861",
"end_time": "2025-09-13 16:33:20.436",
"image_url": "http://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/xxx?Expires=xxx",
"message": ""
},
"usage": {
"image_count": 1
}
}
Generated image URL: http://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/xxx?Expires=xxxImage access permission configuration
Images generated by the model are stored in Alibaba Cloud OSS. Each image is assigned an OSS link, such as https://dashscope-result-xx.oss-cn-xxxx.aliyuncs.com/xxx.png. The OSS link is publicly accessible. You can use this link to view or download the image. The link is valid for only 24 hours.
If your business has high security requirements and cannot access Alibaba Cloud OSS links, you must configure a public access whitelist. Add the following domain names to your whitelist to access the image links.
dashscope-result-bj.oss-cn-beijing.aliyuncs.com
dashscope-result-hz.oss-cn-hangzhou.aliyuncs.com
dashscope-result-sh.oss-cn-shanghai.aliyuncs.com
dashscope-result-wlcb.oss-cn-wulanchabu.aliyuncs.com
dashscope-result-zjk.oss-cn-zhangjiakou.aliyuncs.com
dashscope-result-sz.oss-cn-shenzhen.aliyuncs.com
dashscope-result-hy.oss-cn-heyuan.aliyuncs.com
dashscope-result-cd.oss-cn-chengdu.aliyuncs.com
dashscope-result-gz.oss-cn-guangzhou.aliyuncs.com
dashscope-result-wlcb-acdr-1.oss-cn-wulanchabu-acdr-1.aliyuncs.comError codes
If a call fails, see Error messages for troubleshooting.
FAQ
Q: How to convert a temporary image link to a permanent one?
A: You cannot directly convert a temporary link to a permanent one. Instead, download the image through a backend service and then upload it to Object Storage Service (OSS), to generate a new permanent link.
Q: How to view my model usage?
A: One hour after a request is complete, you can view metrics such as the number of model invocations and success rate on the Model Observation (Singapore) or Model Observation (Beijing) page. For more information, see How do I view model call records?.