Alibaba Cloud Model Studio:Image erase completion API reference

cURL

Create a task:

curl --location --request POST 'https://dashscope.aliyuncs.com/api/v1/services/aigc/image2image/image-synthesis' \
  --header 'X-DashScope-Async: enable' \
  --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "model": "image-erase-completion",
    "input": {
        "image_url": "<your-source-image-url>",
        "mask_url": "<your-mask-image-url>"
    },
    "parameters": {
        "dilate_flag": true
    }
}'

Query the result:

curl -X GET \
  --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
  https://dashscope.aliyuncs.com/api/v1/tasks/<your-task-id>

Replace the following placeholders with your values:

Python

import os
import time
import requests

# Load API key from environment variable
api_key = os.environ.get("DASHSCOPE_API_KEY")
base_url = "https://dashscope.aliyuncs.com/api/v1"
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
    "X-DashScope-Async": "enable"
}

# Step 1: Create a task
create_response = requests.post(
    f"{base_url}/services/aigc/image2image/image-synthesis",
    headers=headers,
    json={
        "model": "image-erase-completion",
        "input": {
            "image_url": "<your-source-image-url>",
            "mask_url": "<your-mask-image-url>"
        },
        "parameters": {
            "dilate_flag": True
        }
    }
)

task_id = create_response.json()["output"]["task_id"]
print(f"Task created: {task_id}")

# Step 2: Poll for the result
query_headers = {"Authorization": f"Bearer {api_key}"}
while True:
    result = requests.get(
        f"{base_url}/tasks/{task_id}",
        headers=query_headers
    ).json()

    status = result["output"]["task_status"]
    if status in ("SUCCEEDED", "FAILED"):
        break
    print(f"Status: {status}, waiting...")
    time.sleep(3)

# Step 3: Download the output image
if status == "SUCCEEDED":
    image_url = result["output"]["output_image_url"]
    print(f"Output image: {image_url}")
    # Download and save the image (URL expires in 24 hours)
    image_data = requests.get(image_url).content
    with open("output-image.png", "wb") as f:
        f.write(image_data)
    print("Image saved to output-image.png")
else:
    print(f"Task failed: {result['output'].get('message', 'Unknown error')}")

Java

import java.io.*;
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;

public class ImageEraseCompletion {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("DASHSCOPE_API_KEY");
        String baseUrl = "https://dashscope.aliyuncs.com/api/v1";
        HttpClient client = HttpClient.newHttpClient();

        // Step 1: Create a task
        String requestBody = """
            {
                "model": "image-erase-completion",
                "input": {
                    "image_url": "<your-source-image-url>",
                    "mask_url": "<your-mask-image-url>"
                },
                "parameters": {
                    "dilate_flag": true
                }
            }
            """;

        HttpRequest createRequest = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/services/aigc/image2image/image-synthesis"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + apiKey)
            .header("X-DashScope-Async", "enable")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();

        HttpResponse<String> createResponse = client.send(
            createRequest, HttpResponse.BodyHandlers.ofString());

        // Parse task_id from JSON response
        String responseBody = createResponse.body();
        String taskId = responseBody.split("\"task_id\":\"")[1].split("\"")[0];
        System.out.println("Task created: " + taskId);

        // Step 2: Poll for the result
        String status;
        String resultBody;
        do {
            Thread.sleep(3000);
            HttpRequest queryRequest = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + "/tasks/" + taskId))
                .header("Authorization", "Bearer " + apiKey)
                .GET()
                .build();

            HttpResponse<String> queryResponse = client.send(
                queryRequest, HttpResponse.BodyHandlers.ofString());
            resultBody = queryResponse.body();
            status = resultBody.split("\"task_status\":\"")[1].split("\"")[0];
            System.out.println("Status: " + status);
        } while (!status.equals("SUCCEEDED") && !status.equals("FAILED"));

        // Step 3: Download the output image
        if (status.equals("SUCCEEDED")) {
            String imageUrl = resultBody.split("\"output_image_url\":\"")[1].split("\"")[0];
            HttpRequest imageRequest = HttpRequest.newBuilder()
                .uri(URI.create(imageUrl))
                .GET()
                .build();

            HttpResponse<byte[]> imageResponse = client.send(
                imageRequest, HttpResponse.BodyHandlers.ofByteArray());
            Files.write(Path.of("output-image.png"), imageResponse.body());
            System.out.println("Image saved to output-image.png");
        } else {
            System.out.println("Task failed: " + resultBody);
        }
    }
}

Node.js

const https = require('https');
const fs = require('fs');

const apiKey = process.env.DASHSCOPE_API_KEY;
const baseUrl = 'https://dashscope.aliyuncs.com/api/v1';

function request(method, url, headers, body) {
    return new Promise((resolve, reject) => {
        const urlObj = new URL(url);
        const options = {
            hostname: urlObj.hostname,
            path: urlObj.pathname,
            method,
            headers
        };

        const req = https.request(options, (res) => {
            let data = '';
            res.on('data', (chunk) => data += chunk);
            res.on('end', () => resolve({ status: res.statusCode, body: data }));
        });

        req.on('error', reject);
        if (body) req.write(body);
        req.end();
    });
}

async function main() {
    // Step 1: Create a task
    const createResponse = await request(
        'POST',
        `${baseUrl}/services/aigc/image2image/image-synthesis`,
        {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`,
            'X-DashScope-Async': 'enable'
        },
        JSON.stringify({
            model: 'image-erase-completion',
            input: {
                image_url: '<your-source-image-url>',
                mask_url: '<your-mask-image-url>'
            },
            parameters: {
                dilate_flag: true
            }
        })
    );

    const taskId = JSON.parse(createResponse.body).output.task_id;
    console.log(`Task created: ${taskId}`);

    // Step 2: Poll for the result
    let status, result;
    do {
        await new Promise(resolve => setTimeout(resolve, 3000));
        const queryResponse = await request(
            'GET',
            `${baseUrl}/tasks/${taskId}`,
            { 'Authorization': `Bearer ${apiKey}` }
        );
        result = JSON.parse(queryResponse.body);
        status = result.output.task_status;
        console.log(`Status: ${status}`);
    } while (status !== 'SUCCEEDED' && status !== 'FAILED');

    // Step 3: Download the output image
    if (status === 'SUCCEEDED') {
        const imageUrl = result.output.output_image_url;
        console.log(`Output image: ${imageUrl}`);

        https.get(imageUrl, (res) => {
            const fileStream = fs.createWriteStream('output-image.png');
            res.pipe(fileStream);
            fileStream.on('finish', () => {
                fileStream.close();
                console.log('Image saved to output-image.png');
            });
        });
    } else {
        console.log(`Task failed: ${result.output.message || 'Unknown error'}`);
    }
}

main().catch(console.error);