curl --request POST \
  --url https://aireiter.com/api/openapi/submit \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "wan2_7_image_pro",
    "params": {
      "prompt": "따뜻한 스튜디오 조명 아래 캔버스에 묘사된 인간 초상화를 정성스럽게 그리는 고양이. 부드러운 집중력을 가진 브러시를 들고 있으며, 세밀하고 사실적인 유화 스타일로 풍부한 질감, 레이어드된 색상과 극적인 조명을 통해 매우 예술적인 분위기를 연출합니다.",
      "output_n": "1",
      "resolution": "2K",
      "aspect_ratio": "auto"
    },
    "out_task_id": "my_task_123456"
  }'

curl --request POST \
  --url https://aireiter.com/api/openapi/submit \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "wan2_7_image_pro",
    "params": {
      "prompt": "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
      "output_n": "1",
      "image_url": ["https://static.aireiter.com/upload/wan2_7_image_pro/20260624/4g7c6b7UyTsOks_XWbVpq.webp"],
      "resolution": "2K",
      "aspect_ratio": "auto"
    },
    "out_task_id": "my_task_img2img_001"
  }'

import requests

url = "https://aireiter.com/api/openapi/submit"

payload = {
    "model": "wan2_7_image_pro",
    "params": {
        "prompt": "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
        "output_n": "1",
        "resolution": "2K",
        "aspect_ratio": "auto"
    },
    "out_task_id": "my_task_123456"
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = "https://aireiter.com/api/openapi/submit";

const payload = {
  model: "wan2_7_image_pro",
  params: {
    prompt: "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
    output_n: "1",
    resolution: "2K",
    aspect_ratio: "auto"
  },
  out_task_id: "my_task_123456"
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://aireiter.com/api/openapi/submit"

    payload := map[string]interface{}{
        "model": "wan2_7_image_pro",
        "params": map[string]interface{}{
            "prompt":       "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
            "output_n":     "1",
            "resolution":   "2K",
            "aspect_ratio": "auto",
        },
        "out_task_id": "my_task_123456",
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://aireiter.com/api/openapi/submit";

        String payload = """
        {
          "model": "wan2_7_image_pro",
          "params": {
            "prompt": "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
            "output_n": "1",
            "resolution": "2K",
            "aspect_ratio": "auto"
          },
          "out_task_id": "my_task_123456"
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://aireiter.com/api/openapi/submit";

$payload = [
    "model" => "wan2_7_image_pro",
    "params" => [
        "prompt" => "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
        "output_n" => "1",
        "resolution" => "2K",
        "aspect_ratio" => "auto"
    ],
    "out_task_id" => "my_task_123456"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://aireiter.com/api/openapi/submit")

payload = {
  model: "wan2_7_image_pro",
  params: {
    prompt: "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
    output_n: "1",
    resolution: "2K",
    aspect_ratio: "auto"
  },
  out_task_id: "my_task_123456"
}

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://aireiter.com/api/openapi/submit")!

let payload: [String: Any] = [
    "model": "wan2_7_image_pro",
    "params": [
        "prompt": "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
        "output_n": "1",
        "resolution": "2K",
        "aspect_ratio": "auto"
    ],
    "out_task_id": "my_task_123456"
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://aireiter.com/api/openapi/submit";

        var payload = @"{
            ""model"": ""wan2_7_image_pro"",
            ""params"": {
                ""prompt"": ""부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이."",
                ""output_n"": ""1"",
                ""resolution"": ""2K"",
                ""aspect_ratio"": ""auto""
            },
            ""out_task_id"": ""my_task_123456""
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://aireiter.com/api/openapi/submit";
        const char *payload = "{"
            "\"model\":\"wan2_7_image_pro\","
            "\"params\":{"
                "\"prompt\":\"부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.\","
                "\"output_n\":\"1\","
                "\"resolution\":\"2K\","
                "\"aspect_ratio\":\"auto\""
            "},"
            "\"out_task_id\":\"my_task_123456\""
        "}";

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Authorization: Bearer <token>");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://aireiter.com/api/openapi/submit"];

        NSDictionary *payload = @{
            @"model": @"wan2_7_image_pro",
            @"params": @{
                @"prompt": @"부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
                @"output_n": @"1",
                @"resolution": @"2K",
                @"aspect_ratio": @"auto"
            },
            @"out_task_id": @"my_task_123456"
        };

        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];

        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];

        NSURLSessionDataTask *task = [[NSURLSession sharedSession]
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];

        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}

(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://aireiter.com/api/openapi/submit"

let payload = {|{
  "model": "wan2_7_image_pro",
  "params": {
    "prompt": "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
    "output_n": "1",
    "resolution": "2K",
    "aspect_ratio": "auto"
  },
  "out_task_id": "my_task_123456"
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "Authorization" "Bearer <token>"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in

  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://aireiter.com/api/openapi/submit');

  final payload = {
    'model': 'wan2_7_image_pro',
    'params': {
      'prompt': '부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.',
      'output_n': '1',
      'resolution': '2K',
      'aspect_ratio': 'auto'
    },
    'out_task_id': 'my_task_123456'
  };

  final response = await http.post(
    url,
    headers: {
      'Authorization': 'Bearer <token>',
      'Content-Type': 'application/json'
    },
    body: jsonEncode(payload),
  );

  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://aireiter.com/api/openapi/submit"

payload <- list(
  model = "wan2_7_image_pro",
  params = list(
    prompt = "부드러운 집중력을 가진 브러시를 들고 이젤 위에 인간 초상화를 정성스럽게 그리는 고양이.",
    output_n = "1",
    resolution = "2K",
    aspect_ratio = "auto"
  ),
  out_task_id = "my_task_123456"
)

response <- POST(
  url,
  add_headers(
    Authorization = "Bearer <token>",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
    "statusCode": 200,
    "message": "",
    "data": {
        "out_task_id": "my_task_123456",
        "status": "pending",
        "estimated_credits": 100,
        "created_at": "2026-06-24T06:03:28.242Z"
    }
}

{
    "statusCode": 400,
    "message": "요청 파라미터가 유효하지 않습니다",
    "ok": false
}

{
  "error": {
    "code": 401,
    "message": "인증 실패, API 키를 확인하세요"
  }
}

{
  "error": {
    "code": 433,
    "message": "계정 잔액 부족, 충전 후 다시 시도하세요"
  }
}

{
  "error": {
    "code": 500,
    "message": "서버 내부 오류, 나중에 다시 시도하세요"
  }
}