API Examples by Language

Shared placeholders

Use these values in all examples:

• <base_url>
• <api_key>
• <history_item_id>
• ./clothes.png
• ./person.png

1) Get Available Tools (GET /generation/tools)

cURL

curl -X GET '<base_url>/generation/tools' \
  -H 'Authorization: Bearer <api_key>'

Python

import requests

response = requests.get(
    '<base_url>/generation/tools',
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
response.raise_for_status()
print(response.json())

JavaScript

const res = await fetch('<base_url>/generation/tools', {
  headers: { Authorization: 'Bearer <api_key>' },
});

if (!res.ok) {
  throw new Error(`Tools request failed: ${res.status}`);
}

console.log(await res.json());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "<base_url>/generation/tools", nil)
	req.Header.Set("Authorization", "Bearer <api_key>")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun getTools() {
    val client = HttpClient(CIO)
    val response = client.get("<base_url>/generation/tools") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

Expected payload (example):

[
  { "group_tool": "fashion", "tool": "lego_clothes", "title": "Lego Clothes" },
  { "group_tool": "fashion", "tool": "mamasfit", "title": "MamasFit" },
  { "group_tool": "fashion", "tool": "lengerie", "title": "Lengerie" },
  { "group_tool": "fashion", "tool": "fashion_card", "title": "Fashion Card" },
  { "group_tool": "fashion", "tool": "fashion_swap", "title": "Fashion Swap" },
  { "group_tool": "fashion", "tool": "fashion_swap_half", "title": "Fashion Swap Half" },
  { "group_tool": "interior", "tool": "furniture", "title": "Furniture" },
  { "group_tool": "textile", "tool": "fabric", "title": "Fabric" },
  { "group_tool": "default", "tool": "default", "title": "Default" }
]

2) Get Generation Types (GET /generation/generationTypes)

cURL

curl -X GET '<base_url>/generation/generationTypes?tool=fashion_swap' \
  -H 'Authorization: Bearer <api_key>'

Python

import requests

response = requests.get(
    '<base_url>/generation/generationTypes',
    params={'tool': 'fashion_swap'},
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
response.raise_for_status()
print(response.json())

JavaScript

const params = new URLSearchParams({ tool: 'fashion_swap' });
const res = await fetch(`<base_url>/generation/generationTypes?${params.toString()}`, {
  headers: { Authorization: 'Bearer <api_key>' },
});

if (!res.ok) {
  throw new Error(`Generation types request failed: ${res.status}`);
}

console.log(await res.json());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "<base_url>/generation/generationTypes?tool=fashion_swap", nil)
	req.Header.Set("Authorization", "Bearer <api_key>")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun getGenerationTypes() {
    val client = HttpClient(CIO)
    val response = client.get("<base_url>/generation/generationTypes") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
        parameter("tool", "fashion_swap")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

3) Create Generation Job (POST /generation/generate_image_v2/)

cURL

curl -X POST '<base_url>/generation/generate_image_v2/' \
  -H 'Authorization: Bearer <api_key>' \
  -H 'Content-Type: multipart/form-data' \
  -F 'tool=fashion_swap' \
  -F 'clothes=@./clothes.png' \
  -F 'person=@./person.png'

Python

import requests

base_url = "<base_url>"
api_key = "<api_key>"

url = f"{base_url}/generation/generate_image_v2/"
headers = {"Authorization": f"Bearer {api_key}"}

with open("./clothes.png", "rb") as clothes_file, open("./person.png", "rb") as person_file:
    files = {
        "clothes": ("clothes.png", clothes_file, "image/png"),
        "person": ("person.png", person_file, "image/png"),
    }
    data = {
        "tool": "fashion_swap",
    }

    response = requests.post(url, headers=headers, files=files, data=data, timeout=120)
    response.raise_for_status()
    print(response.json())

JavaScript

import fs from 'node:fs';

const baseUrl = '<base_url>';
const apiKey = '<api_key>';

const form = new FormData();
form.append('tool', 'fashion_swap');
form.append('clothes', new Blob([fs.readFileSync('./clothes.png')]), 'clothes.png');
form.append('person', new Blob([fs.readFileSync('./person.png')]), 'person.png');

const res = await fetch(`${baseUrl}/generation/generate_image_v2/`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${apiKey}` },
  body: form,
});

if (!res.ok) {
  throw new Error(`Create generation failed: ${res.status} ${await res.text()}`);
}

console.log(await res.json());

Go

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	baseURL := "<base_url>"
	apiKey := "<api_key>"

	var body bytes.Buffer
	writer := multipart.NewWriter(&body)

	addFile := func(fieldName, path string) error {
		f, err := os.Open(path)
		if err != nil {
			return err
		}
		defer f.Close()

		part, err := writer.CreateFormFile(fieldName, path)
		if err != nil {
			return err
		}
		_, err = io.Copy(part, f)
		return err
	}

	if err := addFile("clothes", "./clothes.png"); err != nil {
		panic(err)
	}
	if err := addFile("person", "./person.png"); err != nil {
		panic(err)
	}
	_ = writer.WriteField("tool", "fashion_swap")
	_ = writer.Close()

	req, err := http.NewRequest("POST", baseURL+"/generation/generate_image_v2/", &body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", writer.FormDataContentType())

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

	respBody, _ := io.ReadAll(resp.Body)
	fmt.Printf("status=%d\n%s\n", resp.StatusCode, string(respBody))
}

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.client.request.forms.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json
import java.io.File

suspend fun createGeneration() {
    val baseUrl = "<base_url>"
    val apiKey = "<api_key>"

    val client = HttpClient(CIO) {
        install(ContentNegotiation) {
            json(Json { ignoreUnknownKeys = true })
        }
    }

    val response: HttpResponse = client.submitFormWithBinaryData(
        url = "$baseUrl/generation/generate_image_v2/",
        formData = formData {
            append("tool", "fashion_swap")
            append("clothes", File("./clothes.png").readBytes(), Headers.build {
                append(HttpHeaders.ContentType, "image/png")
                append(HttpHeaders.ContentDisposition, "filename=clothes.png")
            })
            append("person", File("./person.png").readBytes(), Headers.build {
                append(HttpHeaders.ContentType, "image/png")
                append(HttpHeaders.ContentDisposition, "filename=person.png")
            })
        }
    ) {
        header(HttpHeaders.Authorization, "Bearer $apiKey")
    }

    println("status=${response.status}")
    println(response.bodyAsText())
    client.close()
}

4) Check One Job (GET /user/generation-history/{id})

cURL

curl -X GET '<base_url>/user/generation-history/<history_item_id>' \
  -H 'Authorization: Bearer <api_key>'

Python

import requests

response = requests.get(
    '<base_url>/user/generation-history/<history_item_id>',
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
response.raise_for_status()
print(response.json())

JavaScript

const res = await fetch('<base_url>/user/generation-history/<history_item_id>', {
  headers: { Authorization: 'Bearer <api_key>' },
});

if (!res.ok) {
  throw new Error(`Status check failed: ${res.status}`);
}

console.log(await res.json());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "<base_url>/user/generation-history/<history_item_id>", nil)
	req.Header.Set("Authorization", "Bearer <api_key>")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun getGeneration() {
    val client = HttpClient(CIO)
    val response = client.get("<base_url>/user/generation-history/<history_item_id>") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

5) List History (GET /user/generation-history)

cURL

curl -X GET '<base_url>/user/generation-history?page=1&limit=20&status=complete&generation_type=<generation_type_id>' \
  -H 'Authorization: Bearer <api_key>'

Python

import requests

params = {
    'page': 1,
    'limit': 20,
    'status': ['complete'],
    'generation_type': '<generation_type_id>',
}
response = requests.get(
    '<base_url>/user/generation-history',
    params=params,
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
print(response.status_code, response.json())

JavaScript

const params = new URLSearchParams({
  page: '1',
  limit: '20',
  status: 'complete',
  generation_type: '<generation_type_id>',
});

const res = await fetch(`<base_url>/user/generation-history?${params.toString()}`, {
  headers: { Authorization: 'Bearer <api_key>' },
});

console.log(res.status, await res.json());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest(
		"GET",
		"<base_url>/user/generation-history?page=1&limit=20&status=complete&generation_type=<generation_type_id>",
		nil,
	)
	req.Header.Set("Authorization", "Bearer <api_key>")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun listHistory() {
    val client = HttpClient(CIO)
    val response = client.get("<base_url>/user/generation-history") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
        parameter("page", 1)
        parameter("limit", 20)
        parameter("status", "complete")
        parameter("generation_type", "<generation_type_id>")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

6) Send Feedback (PATCH /user/generation-history/feedback/{id})

cURL

curl -X PATCH '<base_url>/user/generation-history/feedback/<history_item_id>' \
  -H 'Authorization: Bearer <api_key>' \
  -H 'Content-Type: application/json' \
  -d '{"like":true}'

Python

import requests

payload = {'like': True}
response = requests.patch(
    '<base_url>/user/generation-history/feedback/<history_item_id>',
    json=payload,
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
print(response.status_code, response.text)

JavaScript

const res = await fetch('<base_url>/user/generation-history/feedback/<history_item_id>', {
  method: 'PATCH',
  headers: {
    Authorization: 'Bearer <api_key>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ like: true }),
});

console.log(res.status, await res.text());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	payload := strings.NewReader(`{"like":true}`)
	req, _ := http.NewRequest("PATCH", "<base_url>/user/generation-history/feedback/<history_item_id>", payload)
	req.Header.Set("Authorization", "Bearer <api_key>")
	req.Header.Set("Content-Type", "application/json")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun sendFeedback() {
    val client = HttpClient(CIO)
    val response = client.patch("<base_url>/user/generation-history/feedback/<history_item_id>") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
        contentType(ContentType.Application.Json)
        setBody("""{"like":true}""")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

7) Delete Record (DELETE /user/generation-history/{id})

cURL

curl -X DELETE '<base_url>/user/generation-history/<history_item_id>' \
  -H 'Authorization: Bearer <api_key>'

Python

import requests

response = requests.delete(
    '<base_url>/user/generation-history/<history_item_id>',
    headers={'Authorization': 'Bearer <api_key>'},
    timeout=30,
)
print(response.status_code, response.text)

JavaScript

const res = await fetch('<base_url>/user/generation-history/<history_item_id>', {
  method: 'DELETE',
  headers: { Authorization: 'Bearer <api_key>' },
});

console.log(res.status, await res.text());

Go

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "<base_url>/user/generation-history/<history_item_id>", nil)
	req.Header.Set("Authorization", "Bearer <api_key>")

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

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

Kotlin (Ktor)

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

suspend fun deleteGeneration() {
    val client = HttpClient(CIO)
    val response = client.delete("<base_url>/user/generation-history/<history_item_id>") {
        header(HttpHeaders.Authorization, "Bearer <api_key>")
    }

    println(response.status)
    println(response.bodyAsText())
    client.close()
}

Use http://localhost:8000/docs to verify exact payload requirements and response schemas in your current backend version.