Image Generation API Integration Guide

POST https://openapi.meitu.com/api/v1/sdk/sync/push
Content-Type: application/json

{
  "parameter": {
    "prompt": "Sunrise over an alpine lake, photorealistic, peaceful composition and warm light",
    "model": "praline_pro",
    "size": "2K",
    "ratio": "16:9"
  }
}

{
  "params": "{\"parameter\":{\"prompt\":\"Sunrise over an alpine lake, photorealistic, peaceful composition and warm light\",\"model\":\"praline_pro\",\"size\":\"2K\",\"ratio\":\"16:9\"}}"
}

{
  "code": 0,
  "error_code": 0,
  "message": "success",
  "data": {
    "progress": 1,
    "result": {
      "id": "example-task-id",
      "media_info_list": [
        {
          "media_data": "https://example.com/result.png",
          "media_extra": {},
          "media_profiles": {
            "media_data_type": "url"
          }
        }
      ],
      "parameters": {}
    },
    "status": 10,
    "task_id": "example-task-id"
  }
}

{
  "code": 0,
  "error_code": 0,
  "message": "success",
  "data": {
    "progress": 0,
    "result": {
      "id": "example-task-id"
    },
    "status": 9,
    "task_id": "example-task-id"
  }
}

{
  "code": 0,
  "error_code": 0,
  "message": "success",
  "data": {
    "progress": 0,
    "result": null,
    "status": 2,
    "task_id": "example-task-id"
  }
}

GET https://openapi.meitu.com/api/v1/sdk/status?task_id=example-task-id

python -m pip install requests

export MEITU_OPENAPI_ACTION='push'
export MEITU_REQUEST_FILE='request.json'

export MEITU_OPENAPI_ACTION='status'
export MEITU_TASK_ID='example-task-id'

import json
import os
from pathlib import Path
from urllib.parse import urlencode

import requests
from sign_sdk import sign

HOST = "openapi.meitu.com"
ACTION = os.environ.get("MEITU_OPENAPI_ACTION", "push")
ak = os.environ["MEITU_OPENAPI_ACCESS_KEY"]
sk = os.environ["MEITU_OPENAPI_SECRET_KEY"]
if not ak or not sk:
    raise ValueError("Missing AK/SK")

if ACTION == "push":
    payload = json.loads(Path(os.environ.get("MEITU_REQUEST_FILE", "request.json")).read_text(encoding="utf-8"))
    if not isinstance(payload.get("params"), str):
        raise ValueError("params must be a JSON string")
    json.loads(payload["params"])
    method = "POST"
    url = f"https://{HOST}/api/v1/sdk/sync/push"
    body = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
elif ACTION == "status":
    task_id = os.environ["MEITU_TASK_ID"]
    if not task_id:
        raise ValueError("Missing task_id")
    method = "GET"
    url = f"https://{HOST}/api/v1/sdk/status?" + urlencode({"task_id": task_id})
    body = ""
else:
    raise ValueError("MEITU_OPENAPI_ACTION must be push or status")

headers = {"Content-Type": "application/json", sign.HeaderHost: HOST}
signed_request = sign.Signer(ak, sk).sign(url, method, headers, body)
with requests.Session() as session:
    response = session.send(signed_request, timeout=(10, 100), verify=True, allow_redirects=False)
    print("HTTP", response.status_code)
    print(response.text)
    response.raise_for_status()

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"time"

	"github.com/mtlab/api/signer"
)

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run() error {
	ak, sk := os.Getenv("MEITU_OPENAPI_ACCESS_KEY"), os.Getenv("MEITU_OPENAPI_SECRET_KEY")
	if ak == "" || sk == "" {
		return fmt.Errorf("missing AK/SK")
	}
	method, endpoint, body := http.MethodPost, "https://openapi.meitu.com/api/v1/sdk/sync/push", ""
	switch os.Getenv("MEITU_OPENAPI_ACTION") {
	case "", "push":
		filename := os.Getenv("MEITU_REQUEST_FILE")
		if filename == "" {
			filename = "request.json"
		}
		raw, err := os.ReadFile(filename)
		if err != nil {
			return err
		}
		var payload map[string]interface{}
		if err = json.Unmarshal(raw, &payload); err != nil {
			return err
		}
		params, ok := payload["params"].(string)
		if !ok || !json.Valid([]byte(params)) {
			return fmt.Errorf("params must be a JSON string")
		}
		body = string(raw)
	case "status":
		taskID := os.Getenv("MEITU_TASK_ID")
		if taskID == "" {
			return fmt.Errorf("missing task_id")
		}
		method = http.MethodGet
		endpoint = "https://openapi.meitu.com/api/v1/sdk/status?" + url.Values{"task_id": {taskID}}.Encode()
	default:
		return fmt.Errorf("MEITU_OPENAPI_ACTION must be push or status")
	}
	headers := make(http.Header)
	headers.Set("Content-Type", "application/json")
	headers.Set(signer.HeaderHost, "openapi.meitu.com")
	req, err := signer.NewSigner(ak, sk).Sign(endpoint, method, headers, body)
	if err != nil {
		return err
	}
	client := &http.Client{Timeout: 100 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	raw, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	fmt.Println("HTTP", resp.StatusCode)
	fmt.Println(string(raw))
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return fmt.Errorf("HTTP request failed")
	}
	return nil
}

<?php
require_once __DIR__ . '/signer.php';

$ak = getenv('MEITU_OPENAPI_ACCESS_KEY');
$sk = getenv('MEITU_OPENAPI_SECRET_KEY');
if (!$ak || !$sk) { throw new RuntimeException('Missing AK/SK'); }
$action = getenv('MEITU_OPENAPI_ACTION') ?: 'push';
$body = '';
if ($action === 'push') {
    $file = getenv('MEITU_REQUEST_FILE') ?: 'request.json';
    $body = file_get_contents($file);
    if ($body === false) { throw new RuntimeException('Cannot read request.json'); }
    $payload = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
    if (!isset($payload['params']) || !is_string($payload['params'])) { throw new RuntimeException('params must be a JSON string'); }
    json_decode($payload['params'], true, 512, JSON_THROW_ON_ERROR);
    $method = 'POST';
    $url = 'https://openapi.meitu.com/api/v1/sdk/sync/push';
} elseif ($action === 'status') {
    $taskId = getenv('MEITU_TASK_ID');
    if (!$taskId) { throw new RuntimeException('Missing task_id'); }
    $method = 'GET';
    $url = 'https://openapi.meitu.com/api/v1/sdk/status?' . http_build_query(['task_id' => $taskId], '', '&', PHP_QUERY_RFC3986);
} else {
    throw new RuntimeException('MEITU_OPENAPI_ACTION must be push or status');
}
$headers = ['Content-Type' => 'application/json', 'Host' => 'openapi.meitu.com'];
$curl = (new Signer($ak, $sk))->sign($url, $method, $headers, $body);
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADER => false,
    CURLOPT_CONNECTTIMEOUT => 10,
    CURLOPT_TIMEOUT => 100,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_SSL_VERIFYPEER => true,
    CURLOPT_SSL_VERIFYHOST => 2,
]);
$response = curl_exec($curl);
if ($response === false) {
    $error = curl_error($curl);
    curl_close($curl);
    throw new RuntimeException($error);
}
$status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
echo 'HTTP ' . $status . PHP_EOL . $response . PHP_EOL;
if ($status < 200 || $status >= 300) { throw new RuntimeException('HTTP request failed'); }

import com.meitu.openai.common.Signer;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;

public class Main {
    private static String requiredEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.isBlank()) throw new IllegalArgumentException("Missing " + name);
        return value;
    }

    public static void main(String[] args) throws Exception {
        String ak = requiredEnv("MEITU_OPENAPI_ACCESS_KEY");
        String sk = requiredEnv("MEITU_OPENAPI_SECRET_KEY");
        String action = System.getenv().getOrDefault("MEITU_OPENAPI_ACTION", "push");
        String method;
        String url;
        String body = "";
        if ("push".equals(action)) {
            String filename = System.getenv().getOrDefault("MEITU_REQUEST_FILE", "request.json");
            body = Files.readString(Path.of(filename), StandardCharsets.UTF_8);
            method = "POST";
            url = "https://openapi.meitu.com/api/v1/sdk/sync/push";
        } else if ("status".equals(action)) {
            method = "GET";
            url = "https://openapi.meitu.com/api/v1/sdk/status?task_id="
                + URLEncoder.encode(requiredEnv("MEITU_TASK_ID"), StandardCharsets.UTF_8);
        } else {
            throw new IllegalArgumentException("MEITU_OPENAPI_ACTION must be push or status");
        }
        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/json");
        headers.put(Signer.HeaderHost, "openapi.meitu.com");
        Map<String, String> signedHeaders = new Signer(ak, sk).sign(url, method, headers, body);
        HttpURLConnection connection = (HttpURLConnection) URI.create(url).toURL().openConnection();
        try {
            connection.setRequestMethod(method);
            connection.setConnectTimeout(10000);
            connection.setReadTimeout(100000);
            connection.setInstanceFollowRedirects(false);
            for (Map.Entry<String, String> header : signedHeaders.entrySet()) connection.setRequestProperty(header.getKey(), header.getValue());
            if ("POST".equals(method)) {
                byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
                connection.setDoOutput(true);
                connection.setFixedLengthStreamingMode(bytes.length);
                try (OutputStream output = connection.getOutputStream()) { output.write(bytes); }
            }
            int status = connection.getResponseCode();
            System.out.println("HTTP " + status);
            InputStream stream = status >= 400 ? connection.getErrorStream() : connection.getInputStream();
            if (stream != null) {
                try (InputStream input = stream) { System.out.println(new String(input.readAllBytes(), StandardCharsets.UTF_8)); }
            }
            if (status < 200 || status >= 300) throw new IllegalStateException("HTTP request failed");
        } finally {
            connection.disconnect();
        }
    }
}

{
  "task": "text-to-image",
  "task_type": "formula",
  "params": "{\"parameter\":{\"prompt\":\"An orange cat sitting on a windowsill, in a minimalist illustration style\"}}",
  "sync_timeout": 30
}

{
  "task": "text-to-image",
  "task_type": "formula",
  "params": "{\"parameter\":{\"prompt\":\"Sunrise over an alpine lake, photorealistic, peaceful composition and warm light\",\"model\":\"praline_pro\",\"size\":\"2K\",\"ratio\":\"16:9\"}}",
  "sync_timeout": 30
}