Flux General Differential Diffusion

Flux General — Flux General Differential Diffusion.

Input

Add your inputs and customize the generation settings.

The prompt to generate an image from.
Upload, drag and drop, or paste a public HTTPS URL.
Selected image

URL of image to use as initial image.
Upload, drag and drop, or paste a public HTTPS URL.
Selected image

URL of change map.

Customize your input with more control.

Calculate credits for your selected settings before generating.

Result & Pricing

Image output — your generated image will appear here.

Your image will appear here

Choose your inputs and customize your settings.

Model pricing (tax excluded) initial reservation per generation

Billing stageHow it works
Reserved creditsA one-time reservation based on 300 compute seconds
Final chargeAdjusted to confirmed usage after generation
Check the credits to reserve before you generate.

Prices, estimates and credit deductions exclude tax. Any applicable tax is charged only when you buy plans or credits.

Initial reservation: credits are reserved before generation. Your final charge is adjusted to confirmed usage after generation. Any unused reserved credits become available again automatically; additional usage may require more credits. The reservation covers compute time, which may differ from the length of your generated media.

  • Prices shown are estimates, not final charges. Final billing details will be available in Reports after generation is complete.

API

WEBOT API · Flux General Differential Diffusion

Generate from your server with your WEBOT account credits.

Use your 120-character WEBOT customer key (a–z, A–Z, 0–9). Send Authorization: Bearer YOUR_KEY. Keys are secrets: call from a server, never from public frontend code. Results come from verified webhooks and remain saved if your stream disconnects.
1. Configure your server
WEBOT_BASE_URL=https://webot.online
WEBOT_API_KEY=<your-server-side-WEBOT-key>

This base URL is resolved from verified domain mappings and your direct creator reseller. Forwarded Host headers are not trusted. New custom reseller domains need DNS, TLS and platform verification before activation.

2. Quote, then generate
MethodEndpointPurpose
POSThttps://webot.online/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quoteValidate input and calculate credits (no deduction).
POSThttps://webot.online/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requestsReserve quoted credits and queue an asynchronous job.
GEThttps://webot.online/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests/{request_id}/resultRead your saved result: 202 pending, 200 terminal.
GEThttps://webot.online/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests/{request_id}/eventsAuthenticated SSE: generation / terminal events.

Send JSON {"input":{…}} to quote. Send the same input plus integer quoted_credits to generate, with Authorization: Bearer … and Idempotency-Key. Use a unique 16–128 character key per new job; persist it and reuse the same key and input on any uncertain response. Never retry with a new key: that creates a second chargeable job.

Credits are reserved only after validation and a durable request is saved. A changed quote or insufficient balance returns 409. Credits exclude purchase taxes. The quoted amount is an initial reservation. After generation, the final charge replaces it using confirmed usage. Any verified unused allocation becomes available automatically; additional usage may require more credits. Missing billing stays pending, including for failed jobs.

3. Input example

Save this as input.json. Replace sample prompts, files and media URLs with your own. Schemas do not guarantee provider acceptance of the content.

{
    "reference_start": 0,
    "base_shift": 0.5,
    "scheduler": "euler",
    "use_real_cfg": false,
    "nag_scale": 3,
    "image_url": "https://webot.online/creative/media/asset/webot-output.jpeg/?token=dih1P09SkM1v5L1fP0dbsS6Jdba4WPVZM-tTIMwKUfOQrZ0gGNTyB2iMj6xQdrdpLZ1xw_noEUQaNiLH3ThnI5kKadxM5imvmwTzIGk0mVNbRJw6",
    "easycontrols": [],
    "nag_end": 0.25,
    "num_inference_steps": 28,
    "strength": 0.85,
    "guidance_scale": 3.5,
    "use_beta_schedule": false,
    "sync_mode": false,
    "enable_safety_checker": true,
    "ip_adapters": [],
    "prompt": "Tree of life under the sea, ethereal, glittering, lens flares, cinematic lighting, artwork by Anna Dittmann & Carne Griffiths, 8k, unreal engine 5, hightly detailed, intricate detailed.",
    "control_loras": [],
    "controlnets": [],
    "output_format": "png",
    "num_images": 1,
    "loras": [],
    "negative_prompt": "",
    "nag_tau": 2.5,
    "change_map_image_url": "https://webot.online/creative/media/asset/webot-output.jpeg/?token=75OkbqeAhQc2MeBk3Y8gCiksbo8fZ9rr1G3_7bcp8A-vVIDRLuL4hhLqEio59ijcGQH0J96l_AZSCGqwfbM0cZEXp2gqJpbnEoAUQAIqYY6EHnqC",
    "controlnet_unions": [],
    "reference_end": 1,
    "use_cfg_zero": false,
    "reference_strength": 0.65,
    "real_cfg_scale": 3.5,
    "max_shift": 1.15,
    "nag_alpha": 0.25
}
4. Language examples
# Save the model's example input as input.json, then replace prompts/media URLs.
# Requires curl and jq. Store NONCE once for this job; reuse it on any retry.
export NONCE="$(openssl rand -hex 16)"
BASE="${WEBOT_BASE_URL%/}"
jq -n --slurpfile input input.json '{input:$input[0]}' > quote-body.json
curl --fail-with-body -sS "$BASE/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote" \
  -H "Authorization: Bearer $WEBOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @quote-body.json > quote.json
CREDITS=$(jq -er '.quote.credits_consumed' quote.json)
jq --argjson credits "$CREDITS" '. + {quoted_credits:$credits}' quote-body.json > request-body.json
curl --fail-with-body -sS "$BASE/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests" \
  -H "Authorization: Bearer $WEBOT_API_KEY" -H "Idempotency-Key: $NONCE" \
  -H 'Content-Type: application/json' --data-binary @request-body.json > job.json
# Subscribe; after a nonterminal disconnect, reconnect this SAME URL.
curl --fail-with-body -N "$(jq -er '.events_url' job.json)" -H "Authorization: Bearer $WEBOT_API_KEY"
# Read saved output after terminal notification (never call provider status/results).
curl --fail-with-body -sS "$(jq -er '.result_url' job.json)" -H "Authorization: Bearer $WEBOT_API_KEY"
// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path, body, nonce) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote', {input});
const job = await post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);
// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL!.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY!;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path: string, body: unknown, nonce?: string) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote', {input});
const job = await post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);
# Python 3.9+, pip install requests
import json, os, time, uuid, requests
base = os.environ['WEBOT_BASE_URL'].rstrip('/')
headers = {'Authorization': 'Bearer ' + os.environ['WEBOT_API_KEY']}
with open('input.json', encoding='utf-8') as file:
    input_data = json.load(file)
nonce = os.environ.get('WEBOT_JOB_NONCE') or str(uuid.uuid4()) # Persist before submitting.
def post(path, body, extra=None):
    response = requests.post(base + path, headers={**headers, **(extra or {})}, json=body, timeout=180)
    response.raise_for_status()
    return response.json()
quote = post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote', {'input': input_data})['quote']
job = post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests', {'input': input_data, 'quoted_credits': quote['credits_consumed']}, {'Idempotency-Key': nonce})
state = job
while not state['terminal'] or state.get('financial_pending', False):
    # Reconnect while nonterminal; this reads WEBOT's database, never a provider status API.
    with requests.get(job['events_url'], headers=headers, stream=True, timeout=(10, 40)) as stream:
        stream.raise_for_status()
        for line in stream.iter_lines(decode_unicode=True):
            if line and line.startswith('data: '):
                state = json.loads(line[6:])
                if 'status' not in state: raise RuntimeError(state)
                if state['terminal'] and not state.get('financial_pending', False): break
    if not state['terminal'] or state.get('financial_pending', False): time.sleep(1.5)
print(state['output'] if state['status'] == 'completed' else state['error'])
<?php // PHP 8.1+ with cURL
$base = rtrim(getenv('WEBOT_BASE_URL'), '/');
$input = json_decode(file_get_contents('input.json'), false, 64, JSON_THROW_ON_ERROR);
$nonce = getenv('WEBOT_JOB_NONCE') ?: bin2hex(random_bytes(16)); // Persist this before submission.
function post(string $path, array $body, ?string $nonce = null): array {
    global $base;
    $headers = ['Authorization: Bearer '.getenv('WEBOT_API_KEY'), 'Content-Type: application/json'];
    if ($nonce) $headers[] = 'Idempotency-Key: '.$nonce;
    $ch = curl_init($base.$path);
    curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER=>true, CURLOPT_POST=>true,
        CURLOPT_TIMEOUT=>180, CURLOPT_HTTPHEADER=>$headers,
        CURLOPT_POSTFIELDS=>json_encode($body, JSON_THROW_ON_ERROR)]);
    $raw = curl_exec($ch); $status = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($raw === false || $status < 200 || $status >= 300) throw new RuntimeException('WEBOT HTTP '.$status);
    return json_decode($raw, true, 64, JSON_THROW_ON_ERROR);
}
$quote = post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote', ['input'=>$input])['quote'];
$job = post('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests', ['input'=>$input, 'quoted_credits'=>$quote['credits_consumed']], $nonce);
echo json_encode($job, JSON_PRETTY_PRINT); // Connect to events_url with the same Bearer header.
// Go 1.20+; save as main.go.
package main
import ("bytes"; "encoding/json"; "fmt"; "io"; "net/http"; "os"; "strings"; "time"; "crypto/rand"; "encoding/hex")
func main() {
    base := strings.TrimRight(os.Getenv("WEBOT_BASE_URL"), "/")
    raw, err := os.ReadFile("input.json"); if err != nil { panic(err) }
    nonce := os.Getenv("WEBOT_JOB_NONCE")
    if nonce == "" { b := make([]byte,16); if _,err:=rand.Read(b);err!=nil {panic(err)}; nonce=hex.EncodeToString(b) }
    // Persist nonce before the submission; reuse on ambiguous responses.
    client := &http.Client{Timeout:180*time.Second}
    post := func(path string, body any, id string) map[string]any {
        data, err := json.Marshal(body); if err != nil {panic(err)}
        req, err := http.NewRequest("POST",base+path,bytes.NewReader(data)); if err!=nil {panic(err)}
        req.Header.Set("Authorization","Bearer "+os.Getenv("WEBOT_API_KEY")); req.Header.Set("Content-Type","application/json")
        if id!="" {req.Header.Set("Idempotency-Key",id)}
        res,err:=client.Do(req); if err!=nil {panic(err)}; defer res.Body.Close()
        data,err=io.ReadAll(res.Body); if err!=nil {panic(err)}
        if res.StatusCode<200||res.StatusCode>=300 {panic(string(data))}
        var result map[string]any; if err=json.Unmarshal(data,&result);err!=nil {panic(err)}; return result
    }
    input:=json.RawMessage(raw)
    quote:=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote",map[string]any{"input":input},"")["quote"].(map[string]any)
    job:=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests",map[string]any{"input":input,"quoted_credits":quote["credits_consumed"]},nonce)
    fmt.Println(job) // Stream events_url with the same Authorization header.
}
// Java 11+, Jackson databind dependency; class Main in Main.java.
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
import java.time.Duration;
import java.util.UUID;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class Main {
  static final ObjectMapper json = new ObjectMapper();
  static final HttpClient client = HttpClient.newHttpClient();
  static final String base = System.getenv("WEBOT_BASE_URL").replaceAll("/$", "");
  static JsonNode post(String path, JsonNode body, String nonce) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(base+path)).timeout(Duration.ofSeconds(180))
      .header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY")).header("Content-Type","application/json")
      .POST(HttpRequest.BodyPublishers.ofString(json.writeValueAsString(body)));
    if(nonce!=null)b.header("Idempotency-Key",nonce);
    var r=client.send(b.build(),HttpResponse.BodyHandlers.ofString());
    if(r.statusCode()<200||r.statusCode()>=300)throw new IllegalStateException(r.body());
    return json.readTree(r.body());
  }
  public static void main(String[] args) throws Exception {
    var input=json.readTree(Files.readString(Path.of("input.json")));
    ObjectNode body=json.createObjectNode();body.set("input",input);
    var quote=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote",body,null).get("quote");
    body.put("quoted_credits",quote.get("credits_consumed").asInt());
    String nonce=System.getenv("WEBOT_JOB_NONCE");if(nonce==null)nonce=UUID.randomUUID().toString(); // Persist before POST.
    var job=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests",body,nonce);System.out.println(job);
    // Subscribe to job.events_url with Authorization; use BodyHandlers.ofLines().
  }
}
// .NET 8 console app, top-level statements.
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
var client = new HttpClient { Timeout = TimeSpan.FromSeconds(180) };
var root = Environment.GetEnvironmentVariable("WEBOT_BASE_URL")!.TrimEnd('/');
var key = Environment.GetEnvironmentVariable("WEBOT_API_KEY");
async Task<JsonNode> Post(string path, JsonNode body, string? nonce = null) {
    using var req = new HttpRequestMessage(HttpMethod.Post, root + path);
    req.Headers.Add("Authorization", "Bearer " + key);
    if (nonce != null) req.Headers.Add("Idempotency-Key", nonce);
    req.Content = new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json");
    using var res = await client.SendAsync(req);
    var raw = await res.Content.ReadAsStringAsync();res.EnsureSuccessStatusCode();
    return JsonNode.Parse(raw)!;
}
var input = JsonNode.Parse(await File.ReadAllTextAsync("input.json"));
var body = new JsonObject { ["input"] = input };
var quote = await Post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote", body);
body["quoted_credits"] = quote["quote"]!["credits_consumed"]!.GetValue<int>();
var nonce = Environment.GetEnvironmentVariable("WEBOT_JOB_NONCE") ?? Guid.NewGuid().ToString(); // Persist before submitting.
var job = await Post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests", body, nonce);
Console.WriteLine(job); // Subscribe to events_url with the same Bearer header and ResponseHeadersRead.
# Ruby 3+, standard library only.
require 'net/http'
require 'json'
require 'securerandom'
base = ENV.fetch('WEBOT_BASE_URL').sub(%r{/$}, '')
post = lambda do |path, body, nonce = nil|
  uri = URI(base + path)
  req = Net::HTTP::Post.new(uri)
  req['Authorization'] = 'Bearer ' + ENV.fetch('WEBOT_API_KEY')
  req['Content-Type'] = 'application/json'
  req['Idempotency-Key'] = nonce if nonce
  req.body = JSON.generate(body)
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 180) { |http| http.request(req) }
  raise res.body unless res.is_a?(Net::HTTPSuccess)
  JSON.parse(res.body)
end
input = JSON.parse(File.read('input.json'))
quote = post.call('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote', {'input' => input})['quote']
nonce = ENV['WEBOT_JOB_NONCE'] || SecureRandom.uuid # Persist this before submission.
job = post.call('/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests', {'input' => input, 'quoted_credits' => quote['credits_consumed']}, nonce)
puts JSON.pretty_generate(job) # Subscribe to events_url with the same Authorization header.
// Swift 5.9 server-side/CLI only. Do not embed customer keys in shipped apps.
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
@main struct Main {
 static func main() async throws {
  let env=ProcessInfo.processInfo.environment
  let base=env["WEBOT_BASE_URL"]!.trimmingCharacters(in: CharacterSet(charactersIn:"/"))
  let input=try JSONSerialization.jsonObject(with: Data(contentsOf:URL(fileURLWithPath:"input.json")))
  func post(_ path:String,_ body:[String:Any],_ nonce:String?=nil) async throws -> [String:Any] {
   var req=URLRequest(url:URL(string:base+path)!);req.httpMethod="POST";req.timeoutInterval=180
   req.setValue("Bearer "+env["WEBOT_API_KEY"]!,forHTTPHeaderField:"Authorization")
   req.setValue("application/json",forHTTPHeaderField:"Content-Type")
   if let nonce {req.setValue(nonce,forHTTPHeaderField:"Idempotency-Key")}
   req.httpBody=try JSONSerialization.data(withJSONObject:body)
   let (data,res)=try await URLSession.shared.data(for:req)
   guard let http=res as? HTTPURLResponse,(200..<300).contains(http.statusCode) else {throw NSError(domain:"WEBOT",code:1)}
   return try JSONSerialization.jsonObject(with:data) as! [String:Any]
  }
  let quote=try await post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote",["input":input])["quote"] as! [String:Any]
  let nonce=env["WEBOT_JOB_NONCE"] ?? UUID().uuidString // Persist before submission.
  let job=try await post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests",["input":input,"quoted_credits":quote["credits_consumed"]!],nonce)
  print(job) // Subscribe to events_url with the same Authorization header.
 }
}
// Server-side Kotlin/JVM 17+, Gradle dependencies: OkHttp 4.12, org.json 20240303.
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.io.File
import java.util.UUID
import java.util.concurrent.TimeUnit
fun main() {
 val base=System.getenv("WEBOT_BASE_URL").trimEnd('/')
 val client=OkHttpClient.Builder().readTimeout(180,TimeUnit.SECONDS).build()
 fun post(path:String,body:JSONObject,nonce:String?=null):JSONObject {
  val b=Request.Builder().url(base+path).header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY"))
   .post(body.toString().toRequestBody("application/json".toMediaType()))
  if(nonce!=null)b.header("Idempotency-Key",nonce)
  return client.newCall(b.build()).execute().use {res ->
   val raw=res.body!!.string();check(res.isSuccessful){raw};JSONObject(raw)
  }
 }
 val body=JSONObject().put("input",JSONObject(File("input.json").readText()))
 val quote=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/quote",body).getJSONObject("quote")
 body.put("quoted_credits",quote.getInt("credits_consumed"))
 val nonce=System.getenv("WEBOT_JOB_NONCE") ?: UUID.randomUUID().toString() // Persist before submission.
 val job=post("/api/v1/models/creative_1deae5f0d258303cf9ac7abb/requests",body,nonce)
 println(job) // Subscribe to events_url with the same Authorization header.
}
5. Receive all results

The response includes a stable WEBOT request_id, events_url and result_url. Subscribe with a Bearer-authenticated HTTP stream. Nonterminal streams end after 25 seconds; reconnect to the same URL after at least 1.5 seconds. Current saved state is replayed immediately, including completion that happened while disconnected. A terminal event contains the result envelope. The JSON terminal flag describes generation completion. Keep reconnecting while financial_pending is true; stop after the terminal event confirms financial settlement. Never poll provider status/results. Native browser EventSource cannot send a Bearer header; keep the key on your server.

Completed output contains the full model result, including every generated media/document item, not just the first URL. Failed output is null with error and refund_state. Results are strictly limited to the key owner, including on reseller domains. Model-independent aliases: /api/v1/requests/{request_id}/result and /events. Revoking a key blocks subsequent reads and streams; saved results remain accessible with another valid key of the same account.

6. Schemas and parameter defaults

Required fields are marked with *. Required text must contain non-whitespace content. Defaults apply when an optional parameter is omitted; null, false, 0 and an empty array are distinct values. “No documented default” means WEBOT does not invent one. Examples are sample inputs, not defaults. WEBOT generation constraints can require an explicit value even when the provider publishes an automatic default.

Input schema · fields, constraints and defaults
ParameterTypeRequiredDefault when omittedDescription / constraints
reference_startnumberNo0 The percentage of the total timesteps when the reference guidance is to bestarted.
minimum: 0 · maximum: 1
base_shiftnumberNo0.5Base shift for the scheduled timesteps
minimum: 0.01 · maximum: 5
schedulerstringNo"euler"Scheduler for the denoising process.
enum: ["euler","dpmpp_2m"]
seedinteger | nullNoNo documented default The same seed and the same prompt given to the same version of the model will output the same image every time.
use_real_cfgbooleanNofalse Uses classical CFG as in SD1.5, SDXL, etc. Increases generation times and price when set to be true. If using XLabs IP-Adapter v1, this will be turned on!.
nag_scalenumberNo3 The scale for NAG. Higher values will result in a image that is more distant to the negative prompt.
maximum: 10 · exclusiveMinimum: 1
image_urlstringYes *No documented defaultURL of image to use as initial image.
easycontrolsarrayNo[] EasyControl Inputs to use for image generation.
easycontrols[].image_urlstringYes *No documented defaultURL of an image to use as a control
easycontrols[].control_method_urlstringYes *No documented defaultURL to safetensor weights of control method to be applied. Can also be one of `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`
easycontrols[].image_control_typestringYes *No documented defaultControl type of the image. Must be one of `spatial` or `subject`.
enum: ["subject","spatial"]
easycontrols[].scalenumberNo1Scale for the control method.
minimum: 0 · maximum: 2
nag_endnumberNo0.25 The proportion of steps to apply NAG. After the specified proportion of steps has been iterated, the remaining steps will use original attention processors in FLUX.
maximum: 1 · exclusiveMinimum: 0
num_inference_stepsintegerNo28The number of inference steps to perform.
minimum: 1 · maximum: 50
strengthnumberNo0.85The strength to use for differential diffusion. 1.0 is completely remakes the image while 0.0 preserves the original.
minimum: 0.01 · maximum: 1
image_sizeobject | stringNoNo documented defaultThe size of the generated image.
image_size.variant0.widthintegerNo512The width of the generated image.
maximum: 14142 · exclusiveMinimum: 0
image_size.variant0.heightintegerNo512The height of the generated image.
maximum: 14142 · exclusiveMinimum: 0
guidance_scalenumberNo3.5 The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you.
minimum: 0 · maximum: 20
use_beta_schedulebooleanNofalseSpecifies whether beta sigmas ought to be used.
sync_modebooleanNofalseIf `True`, the media will be returned as a data URI and the output data won't be available in the request history.
enable_safety_checkerbooleanNotrueIf set to true, the safety checker will be enabled. Disabling it requires account authorization; unauthorized requests are always checked, and images flagged as unsafe are returned as black images.
ip_adaptersarrayNo[] IP-Adapter to use for image generation.
ip_adapters[].pathstringYes *No documented defaultHugging Face path to the IP-Adapter
ip_adapters[].weight_namestring | nullNoNo documented defaultName of the safetensors file containing the ip-adapter weights
ip_adapters[].subfolderstring | nullNoNo documented defaultSubfolder in which the ip_adapter weights exist
ip_adapters[].mask_image_urlstring | nullNoNo documented defaultURL of the mask for the control image.
ip_adapters[].mask_thresholdnumberNo0.5Threshold for mask.
minimum: 0.01 · maximum: 0.99
ip_adapters[].image_encoder_pathstringYes *No documented defaultPath to the Image Encoder for the IP-Adapter, for example 'openai/clip-vit-large-patch14'
ip_adapters[].image_encoder_weight_namestring | nullNoNo documented defaultName of the image encoder.
ip_adapters[].image_encoder_subfolderstring | nullNoNo documented defaultSubfolder in which the image encoder weights exist.
ip_adapters[].image_urlstringYes *No documented defaultURL of Image for IP-Adapter conditioning.
ip_adapters[].scalenumberYes *No documented defaultScale for ip adapter.
promptstringYes *No documented defaultThe prompt to generate an image from.
control_lorasarrayNo[] The LoRAs to use for the image generation which use a control image. You can use any number of LoRAs and they will be merged together to generate the final image.
control_loras[].pathstringYes *No documented defaultURL or the path to the LoRA weights.
control_loras[].scaleobject | numberNo1 The scale of the LoRA weight. This is used to scale the LoRA weight before merging it with the base model. Providing a dictionary as {"layer_name":layer_scale} allows per-layer lora scale settings. Layers with no scale provided will have scale 1.0.
control_loras[].preprocessstringNo"None"Type of preprocessing to apply to the input image.
enum: ["canny","depth","None"]
control_loras[].control_image_urlstringYes *No documented defaultURL of the image to be used as the control image.
controlnetsarrayNo[] The controlnets to use for the image generation. Only one controlnet is supported at the moment.
controlnets[].pathstringYes *No documented defaultURL or the path to the control net weights.
controlnets[].mask_image_urlstringNoNo documented defaultURL of the mask for the control image.
controlnets[].start_percentagenumberNo0 The percentage of the image to start applying the controlnet in terms of the total timesteps.
minimum: 0 · maximum: 1
controlnets[].mask_thresholdnumberNo0.5Threshold for mask.
minimum: 0.01 · maximum: 0.99
controlnets[].config_urlstring | nullNoNo documented defaultoptional URL to the controlnet config.json file.
controlnets[].variantstring | nullNoNo documented defaultThe optional variant if a Hugging Face repo key is used.
controlnets[].end_percentagenumberNo1 The percentage of the image to end applying the controlnet in terms of the total timesteps.
minimum: 0 · maximum: 1
controlnets[].conditioning_scalenumberNo1 The scale of the control net weight. This is used to scale the control net weight before merging it with the base model.
minimum: 0 · maximum: 2
controlnets[].control_image_urlstringYes *No documented defaultURL of the image to be used as the control image.
output_formatstringNo"png"The format of the generated image.
enum: ["jpeg","png"]
fill_imageobject | nullNoNo documented defaultUse an image input to influence the generation. Can be used to fill images in masked areas.
fill_image.variant0.fill_image_urlstring | arrayNo[]URLs of images to be filled for redux prompting
num_imagesintegerNo1The number of images to generate. This is always set to 1 for streaming output.
minimum: 1 · maximum: 10
lorasarrayNo[] The LoRAs to use for the image generation. You can use any number of LoRAs and they will be merged together to generate the final image.
loras[].pathstringYes *No documented defaultURL or the path to the LoRA weights.
loras[].scaleobject | numberNo1 The scale of the LoRA weight. This is used to scale the LoRA weight before merging it with the base model. Providing a dictionary as {"layer_name":layer_scale} allows per-layer lora scale settings. Layers with no scale provided will have scale 1.0.
negative_promptstringNo"" Negative prompt to steer the image generation away from unwanted features. By default, we will be using NAG for processing the negative prompt.
nag_taunumberNo2.5 The tau for NAG. Controls the normalization of the hidden state. Higher values will result in a less aggressive normalization, but may also lead to unexpected changes with respect to the original image. Not recommended to change this value.
exclusiveMinimum: 0
reference_image_urlstringNoNo documented defaultURL of Image for Reference-Only
change_map_image_urlstringYes *No documented defaultURL of change map.
controlnet_unionsarrayNo[] The controlnet unions to use for the image generation. Only one controlnet is supported at the moment.
controlnet_unions[].pathstringYes *No documented defaultURL or the path to the control net weights.
controlnet_unions[].variantstring | nullNoNo documented defaultThe optional variant if a Hugging Face repo key is used.
controlnet_unions[].config_urlstring | nullNoNo documented defaultoptional URL to the controlnet config.json file.
controlnet_unions[].controlsarrayYes *No documented defaultThe control images and modes to use for the control net.
controlnet_unions[].controls[].end_percentagenumberNo1 The percentage of the image to end applying the controlnet in terms of the total timesteps.
minimum: 0 · maximum: 1
controlnet_unions[].controls[].start_percentagenumberNo0 The percentage of the image to start applying the controlnet in terms of the total timesteps.
minimum: 0 · maximum: 1
controlnet_unions[].controls[].control_modestringYes *No documented defaultControl Mode for Flux Controlnet Union. Supported values are: - canny: Uses the edges for guided generation. - tile: Uses the tiles for guided generation. - depth: Utilizes a grayscale depth map for guided generation. - blur: Adds a blur to the image. - pose: Uses the pose of the image for guided generation. - gray: Converts the image to grayscale. - low-quality: Converts the image to a low-quality image.
enum: ["canny","tile","depth","blur","pose","gray","low-quality"]
controlnet_unions[].controls[].mask_image_urlstringNoNo documented defaultURL of the mask for the control image.
controlnet_unions[].controls[].conditioning_scalenumberNo1 The scale of the control net weight. This is used to scale the control net weight before merging it with the base model.
minimum: 0 · maximum: 2
controlnet_unions[].controls[].mask_thresholdnumberNo0.5Threshold for mask.
minimum: 0.01 · maximum: 0.99
controlnet_unions[].controls[].control_image_urlstringYes *No documented defaultURL of the image to be used as the control image.
reference_endnumberNo1 The percentage of the total timesteps when the reference guidance is to be ended.
minimum: 0 · maximum: 1
use_cfg_zerobooleanNofalse Uses CFG-zero init sampling as in https://arxiv.org/abs/2503.18886.
sigma_schedulestring | nullNoNo documented defaultSigmas schedule for the denoising process.
reference_strengthnumberNo0.65Strength of reference_only generation. Only used if a reference image is provided.
minimum: -3 · maximum: 3
real_cfg_scalenumberNo3.5 The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you.
minimum: 0 · maximum: 5
max_shiftnumberNo1.15Max shift for the scheduled timesteps
minimum: 0.01 · maximum: 5
nag_alphanumberNo0.25 The alpha value for NAG. This value is used as a final weighting factor for steering the normalized guidance (positive and negative prompts) in the direction of the positive prompt. Higher values will result in less steering on the normalized guidance where lower values will result in considering the positive prompt guidance more.
maximum: 1 · exclusiveMinimum: 0
{
    "title": "DifferentialDiffusionInput",
    "required": [
        "prompt",
        "image_url",
        "change_map_image_url"
    ],
    "x-webot-order-properties": [
        "prompt",
        "image_size",
        "num_inference_steps",
        "seed",
        "loras",
        "control_loras",
        "controlnets",
        "controlnet_unions",
        "ip_adapters",
        "easycontrols",
        "fill_image",
        "guidance_scale",
        "real_cfg_scale",
        "use_real_cfg",
        "use_cfg_zero",
        "sync_mode",
        "num_images",
        "enable_safety_checker",
        "reference_image_url",
        "reference_strength",
        "reference_start",
        "reference_end",
        "base_shift",
        "max_shift",
        "output_format",
        "use_beta_schedule",
        "sigma_schedule",
        "scheduler",
        "negative_prompt",
        "nag_scale",
        "nag_tau",
        "nag_alpha",
        "nag_end",
        "image_url",
        "change_map_image_url",
        "strength"
    ],
    "properties": {
        "reference_start": {
            "title": "Reference Start",
            "default": 0,
            "type": "number",
            "maximum": 1,
            "description": "\n            The percentage of the total timesteps when the reference guidance is to bestarted.\n        ",
            "minimum": 0
        },
        "base_shift": {
            "title": "Base Shift",
            "default": 0.5,
            "type": "number",
            "maximum": 5,
            "description": "Base shift for the scheduled timesteps",
            "minimum": 0.01
        },
        "scheduler": {
            "title": "Scheduler",
            "default": "euler",
            "description": "Scheduler for the denoising process.",
            "enum": [
                "euler",
                "dpmpp_2m"
            ],
            "type": "string"
        },
        "seed": {
            "title": "Seed",
            "anyOf": [
                {
                    "type": "integer"
                },
                {
                    "type": "null"
                }
            ],
            "description": "\n            The same seed and the same prompt given to the same version of the model\n            will output the same image every time.\n        "
        },
        "use_real_cfg": {
            "title": "Use Real CFG",
            "default": false,
            "description": "\n            Uses classical CFG as in SD1.5, SDXL, etc. Increases generation times and price when set to be true.\n            If using XLabs IP-Adapter v1, this will be turned on!.\n        ",
            "type": "boolean"
        },
        "nag_scale": {
            "title": "NAG scale",
            "default": 3,
            "exclusiveMinimum": 1,
            "maximum": 10,
            "description": "\n            The scale for NAG. Higher values will result in a image that is more distant\n            to the negative prompt.\n        ",
            "type": "number"
        },
        "image_url": {
            "title": "Image URL",
            "type": "string",
            "description": "URL of image to use as initial image."
        },
        "easycontrols": {
            "title": "Easycontrols",
            "default": [],
            "items": {
                "title": "EasyControlWeight",
                "required": [
                    "control_method_url",
                    "image_url",
                    "image_control_type"
                ],
                "x-webot-order-properties": [
                    "control_method_url",
                    "scale",
                    "image_url",
                    "image_control_type"
                ],
                "properties": {
                    "image_url": {
                        "title": "Image Url",
                        "description": "URL of an image to use as a control",
                        "type": "string"
                    },
                    "control_method_url": {
                        "title": "Control Method Url",
                        "type": "string",
                        "description": "URL to safetensor weights of control method to be applied. Can also be one of `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli` ",
                        "examples": [
                            "canny",
                            "depth",
                            "hedsketch",
                            "inpainting",
                            "pose",
                            "seg",
                            "subject",
                            "ghibli"
                        ]
                    },
                    "image_control_type": {
                        "title": "Image Control Type",
                        "description": "Control type of the image. Must be one of `spatial` or `subject`.",
                        "enum": [
                            "subject",
                            "spatial"
                        ],
                        "type": "string"
                    },
                    "scale": {
                        "title": "Scale",
                        "default": 1,
                        "type": "number",
                        "maximum": 2,
                        "description": "Scale for the control method.",
                        "minimum": 0
                    }
                },
                "type": "object"
            },
            "description": "\n        EasyControl Inputs to use for image generation.\n        ",
            "type": "array"
        },
        "nag_end": {
            "title": "Proportion of steps to apply NAG",
            "default": 0.25,
            "exclusiveMinimum": 0,
            "maximum": 1,
            "description": "\n            The proportion of steps to apply NAG. After the specified proportion\n            of steps has been iterated, the remaining steps will use original\n            attention processors in FLUX.\n        ",
            "type": "number"
        },
        "num_inference_steps": {
            "title": "Num Inference Steps",
            "default": 28,
            "type": "integer",
            "maximum": 50,
            "description": "The number of inference steps to perform.",
            "minimum": 1
        },
        "strength": {
            "title": "Strength",
            "default": 0.85,
            "type": "number",
            "maximum": 1,
            "description": "The strength to use for differential diffusion. 1.0 is completely remakes the image while 0.0 preserves the original.",
            "minimum": 0.01
        },
        "image_size": {
            "title": "Image Size",
            "anyOf": [
                {
                    "title": "ImageSize",
                    "type": "object",
                    "x-webot-order-properties": [
                        "width",
                        "height"
                    ],
                    "properties": {
                        "width": {
                            "title": "Width",
                            "default": 512,
                            "exclusiveMinimum": 0,
                            "maximum": 14142,
                            "description": "The width of the generated image.",
                            "type": "integer"
                        },
                        "height": {
                            "title": "Height",
                            "default": 512,
                            "exclusiveMinimum": 0,
                            "maximum": 14142,
                            "description": "The height of the generated image.",
                            "type": "integer"
                        }
                    }
                },
                {
                    "enum": [
                        "square_hd",
                        "square",
                        "portrait_4_3",
                        "portrait_16_9",
                        "landscape_4_3",
                        "landscape_16_9"
                    ],
                    "type": "string"
                }
            ],
            "description": "The size of the generated image."
        },
        "guidance_scale": {
            "title": "Guidance scale (CFG)",
            "default": 3.5,
            "type": "number",
            "maximum": 20,
            "description": "\n            The CFG (Classifier Free Guidance) scale is a measure of how close you want\n            the model to stick to your prompt when looking for a related image to show you.\n        ",
            "minimum": 0
        },
        "use_beta_schedule": {
            "title": "Use Beta Schedule",
            "default": false,
            "description": "Specifies whether beta sigmas ought to be used.",
            "type": "boolean"
        },
        "sync_mode": {
            "title": "Sync Mode",
            "default": false,
            "description": "If `True`, the media will be returned as a data URI and the output data won't be available in the request history.",
            "type": "boolean"
        },
        "enable_safety_checker": {
            "title": "Enable Safety Checker",
            "default": true,
            "description": "If set to true, the safety checker will be enabled. Disabling it requires account authorization; unauthorized requests are always checked, and images flagged as unsafe are returned as black images.",
            "type": "boolean"
        },
        "ip_adapters": {
            "title": "Ip Adapters",
            "default": [],
            "items": {
                "title": "IPAdapter",
                "required": [
                    "path",
                    "image_encoder_path",
                    "image_url",
                    "scale"
                ],
                "x-webot-order-properties": [
                    "path",
                    "subfolder",
                    "weight_name",
                    "image_encoder_path",
                    "image_encoder_subfolder",
                    "image_encoder_weight_name",
                    "image_url",
                    "mask_image_url",
                    "mask_threshold",
                    "scale"
                ],
                "properties": {
                    "path": {
                        "title": "Path",
                        "description": "Hugging Face path to the IP-Adapter",
                        "type": "string"
                    },
                    "weight_name": {
                        "title": "Weight Name",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "Name of the safetensors file containing the ip-adapter weights"
                    },
                    "subfolder": {
                        "title": "Subfolder",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "Subfolder in which the ip_adapter weights exist"
                    },
                    "mask_image_url": {
                        "title": "Mask Image Url",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "URL of the mask for the control image."
                    },
                    "mask_threshold": {
                        "title": "Mask Threshold",
                        "default": 0.5,
                        "type": "number",
                        "maximum": 0.99,
                        "description": "Threshold for mask.",
                        "minimum": 0.01
                    },
                    "image_encoder_path": {
                        "title": "Image Encoder Path",
                        "description": "Path to the Image Encoder for the IP-Adapter, for example 'openai/clip-vit-large-patch14'",
                        "type": "string"
                    },
                    "image_encoder_weight_name": {
                        "title": "Image Encoder Weight Name",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "Name of the image encoder."
                    },
                    "image_encoder_subfolder": {
                        "title": "Image Encoder Subfolder",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "Subfolder in which the image encoder weights exist."
                    },
                    "image_url": {
                        "title": "Image Url",
                        "description": "URL of Image for IP-Adapter conditioning. ",
                        "type": "string"
                    },
                    "scale": {
                        "title": "Scale",
                        "description": "Scale for ip adapter.",
                        "type": "number"
                    }
                },
                "type": "object"
            },
            "description": "\n        IP-Adapter to use for image generation.\n        ",
            "type": "array"
        },
        "prompt": {
            "title": "Prompt",
            "type": "string",
            "description": "The prompt to generate an image from.",
            "examples": [
                "Tree of life under the sea, ethereal, glittering, lens flares, cinematic lighting, artwork by Anna Dittmann & Carne Griffiths, 8k, unreal engine 5, hightly detailed, intricate detailed."
            ]
        },
        "control_loras": {
            "title": "Control Loras",
            "default": [],
            "examples": [],
            "items": {
                "title": "ControlLoraWeight",
                "required": [
                    "path",
                    "control_image_url"
                ],
                "x-webot-order-properties": [
                    "path",
                    "scale",
                    "control_image_url",
                    "preprocess"
                ],
                "properties": {
                    "path": {
                        "title": "Path",
                        "description": "URL or the path to the LoRA weights.",
                        "type": "string"
                    },
                    "scale": {
                        "title": "Scale",
                        "default": 1,
                        "anyOf": [
                            {
                                "title": "Per-layer LoRA scales",
                                "additionalProperties": {
                                    "type": "number",
                                    "maximum": 4,
                                    "minimum": -4
                                },
                                "type": "object",
                                "examples": [
                                    {
                                        "transformer": 0.8
                                    }
                                ]
                            },
                            {
                                "title": "Uniform LoRA scale",
                                "type": "number",
                                "examples": [
                                    1
                                ],
                                "maximum": 4,
                                "minimum": -4
                            }
                        ],
                        "description": "\n            The scale of the LoRA weight. This is used to scale the LoRA weight\n            before merging it with the base model. Providing a dictionary as {\"layer_name\":layer_scale} allows per-layer lora scale settings. Layers with no scale provided will have scale 1.0.\n        "
                    },
                    "preprocess": {
                        "title": "Preprocess",
                        "default": "None",
                        "description": "Type of preprocessing to apply to the input image.",
                        "enum": [
                            "canny",
                            "depth",
                            "None"
                        ],
                        "type": "string"
                    },
                    "control_image_url": {
                        "title": "Control Image Url",
                        "description": "URL of the image to be used as the control image.",
                        "type": "string"
                    }
                },
                "type": "object"
            },
            "description": "\n            The LoRAs to use for the image generation which use a control image. You can use any number of LoRAs\n            and they will be merged together to generate the final image.\n        ",
            "type": "array"
        },
        "controlnets": {
            "title": "Controlnets",
            "default": [],
            "items": {
                "title": "ControlNet",
                "required": [
                    "path",
                    "control_image_url"
                ],
                "x-webot-order-properties": [
                    "path",
                    "config_url",
                    "variant",
                    "control_image_url",
                    "mask_image_url",
                    "mask_threshold",
                    "conditioning_scale",
                    "start_percentage",
                    "end_percentage"
                ],
                "properties": {
                    "path": {
                        "title": "Path",
                        "description": "URL or the path to the control net weights.",
                        "type": "string"
                    },
                    "mask_image_url": {
                        "title": "Mask Image Url",
                        "description": "URL of the mask for the control image.",
                        "type": "string"
                    },
                    "start_percentage": {
                        "title": "Start Percentage",
                        "default": 0,
                        "type": "number",
                        "maximum": 1,
                        "description": "\n            The percentage of the image to start applying the controlnet in terms of the total timesteps.\n        ",
                        "minimum": 0
                    },
                    "mask_threshold": {
                        "title": "Mask Threshold",
                        "default": 0.5,
                        "type": "number",
                        "maximum": 0.99,
                        "description": "Threshold for mask.",
                        "minimum": 0.01
                    },
                    "config_url": {
                        "title": "Config Url",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "optional URL to the controlnet config.json file."
                    },
                    "variant": {
                        "title": "Variant",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "The optional variant if a Hugging Face repo key is used."
                    },
                    "end_percentage": {
                        "title": "End Percentage",
                        "default": 1,
                        "type": "number",
                        "maximum": 1,
                        "description": "\n            The percentage of the image to end applying the controlnet in terms of the total timesteps.\n        ",
                        "minimum": 0
                    },
                    "conditioning_scale": {
                        "title": "Conditioning Scale",
                        "default": 1,
                        "type": "number",
                        "maximum": 2,
                        "description": "\n            The scale of the control net weight. This is used to scale the control net weight\n            before merging it with the base model.\n        ",
                        "minimum": 0
                    },
                    "control_image_url": {
                        "title": "Control Image Url",
                        "description": "URL of the image to be used as the control image.",
                        "type": "string"
                    }
                },
                "type": "object"
            },
            "description": "\n            The controlnets to use for the image generation. Only one controlnet is supported at the moment.\n        ",
            "type": "array"
        },
        "output_format": {
            "title": "Output Format",
            "default": "png",
            "description": "The format of the generated image.",
            "enum": [
                "jpeg",
                "png"
            ],
            "type": "string"
        },
        "fill_image": {
            "anyOf": [
                {
                    "title": "ImageFillInput",
                    "type": "object",
                    "x-webot-order-properties": [
                        "fill_image_url"
                    ],
                    "properties": {
                        "fill_image_url": {
                            "title": "Fill Image Url",
                            "default": [],
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "items": {
                                        "type": "string"
                                    },
                                    "type": "array"
                                }
                            ],
                            "description": "URLs of images to be filled for redux prompting"
                        }
                    }
                },
                {
                    "type": "null"
                }
            ],
            "description": "Use an image input to influence the generation. Can be used to fill images in masked areas."
        },
        "num_images": {
            "title": "Num Images",
            "default": 1,
            "type": "integer",
            "maximum": 10,
            "description": "The number of images to generate. This is always set to 1 for streaming output.",
            "minimum": 1
        },
        "loras": {
            "title": "Loras",
            "default": [],
            "examples": [],
            "items": {
                "title": "LoraWeight",
                "required": [
                    "path"
                ],
                "x-webot-order-properties": [
                    "path",
                    "scale"
                ],
                "properties": {
                    "path": {
                        "title": "Path",
                        "description": "URL or the path to the LoRA weights.",
                        "type": "string"
                    },
                    "scale": {
                        "title": "Scale",
                        "default": 1,
                        "anyOf": [
                            {
                                "title": "Per-layer LoRA scales",
                                "additionalProperties": {
                                    "type": "number",
                                    "maximum": 4,
                                    "minimum": -4
                                },
                                "type": "object",
                                "examples": [
                                    {
                                        "transformer": 0.8
                                    }
                                ]
                            },
                            {
                                "title": "Uniform LoRA scale",
                                "type": "number",
                                "examples": [
                                    1
                                ],
                                "maximum": 4,
                                "minimum": -4
                            }
                        ],
                        "description": "\n            The scale of the LoRA weight. This is used to scale the LoRA weight\n            before merging it with the base model. Providing a dictionary as {\"layer_name\":layer_scale} allows per-layer lora scale settings. Layers with no scale provided will have scale 1.0.\n        "
                    }
                },
                "type": "object"
            },
            "description": "\n            The LoRAs to use for the image generation. You can use any number of LoRAs\n            and they will be merged together to generate the final image.\n        ",
            "type": "array"
        },
        "negative_prompt": {
            "title": "Negative Prompt",
            "default": "",
            "description": "\n            Negative prompt to steer the image generation away from unwanted features.\n            By default, we will be using NAG for processing the negative prompt.\n        ",
            "type": "string"
        },
        "nag_tau": {
            "title": "NAG Tau",
            "default": 2.5,
            "exclusiveMinimum": 0,
            "description": "\n            The tau for NAG. Controls the normalization of the hidden state.\n            Higher values will result in a less aggressive normalization,\n            but may also lead to unexpected changes with respect to the original image.\n            Not recommended to change this value.\n        ",
            "type": "number"
        },
        "reference_image_url": {
            "title": "Reference Image Url",
            "description": "URL of Image for Reference-Only",
            "type": "string"
        },
        "change_map_image_url": {
            "title": "Change Map URL",
            "type": "string",
            "description": "URL of change map."
        },
        "controlnet_unions": {
            "title": "Controlnet Unions",
            "default": [],
            "items": {
                "title": "ControlNetUnion",
                "required": [
                    "path",
                    "controls"
                ],
                "x-webot-order-properties": [
                    "path",
                    "config_url",
                    "variant",
                    "controls"
                ],
                "properties": {
                    "path": {
                        "title": "Path",
                        "description": "URL or the path to the control net weights.",
                        "type": "string"
                    },
                    "variant": {
                        "title": "Variant",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "The optional variant if a Hugging Face repo key is used."
                    },
                    "config_url": {
                        "title": "Config Url",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ],
                        "description": "optional URL to the controlnet config.json file."
                    },
                    "controls": {
                        "title": "Controls",
                        "items": {
                            "title": "ControlNetUnionInput",
                            "required": [
                                "control_image_url",
                                "control_mode"
                            ],
                            "x-webot-order-properties": [
                                "control_image_url",
                                "mask_image_url",
                                "control_mode",
                                "conditioning_scale",
                                "mask_threshold",
                                "start_percentage",
                                "end_percentage"
                            ],
                            "properties": {
                                "end_percentage": {
                                    "title": "End Percentage",
                                    "default": 1,
                                    "type": "number",
                                    "maximum": 1,
                                    "description": "\n            The percentage of the image to end applying the controlnet in terms of the total timesteps.\n        ",
                                    "minimum": 0
                                },
                                "start_percentage": {
                                    "title": "Start Percentage",
                                    "default": 0,
                                    "type": "number",
                                    "maximum": 1,
                                    "description": "\n            The percentage of the image to start applying the controlnet in terms of the total timesteps.\n        ",
                                    "minimum": 0
                                },
                                "control_mode": {
                                    "title": "Control Mode",
                                    "description": "Control Mode for Flux Controlnet Union. Supported values are:\n        - canny: Uses the edges for guided generation.\n        - tile: Uses the tiles for guided generation.\n        - depth: Utilizes a grayscale depth map for guided generation.\n        - blur: Adds a blur to the image.\n        - pose: Uses the pose of the image for guided generation.\n        - gray: Converts the image to grayscale.\n        - low-quality: Converts the image to a low-quality image.",
                                    "enum": [
                                        "canny",
                                        "tile",
                                        "depth",
                                        "blur",
                                        "pose",
                                        "gray",
                                        "low-quality"
                                    ],
                                    "type": "string"
                                },
                                "mask_image_url": {
                                    "title": "Mask Image Url",
                                    "description": "URL of the mask for the control image.",
                                    "type": "string"
                                },
                                "conditioning_scale": {
                                    "title": "Conditioning Scale",
                                    "default": 1,
                                    "type": "number",
                                    "maximum": 2,
                                    "description": "\n            The scale of the control net weight. This is used to scale the control net weight\n            before merging it with the base model.\n        ",
                                    "minimum": 0
                                },
                                "mask_threshold": {
                                    "title": "Mask Threshold",
                                    "default": 0.5,
                                    "type": "number",
                                    "maximum": 0.99,
                                    "description": "Threshold for mask.",
                                    "minimum": 0.01
                                },
                                "control_image_url": {
                                    "title": "Control Image Url",
                                    "description": "URL of the image to be used as the control image.",
                                    "type": "string"
                                }
                            },
                            "type": "object"
                        },
                        "description": "The control images and modes to use for the control net.",
                        "type": "array"
                    }
                },
                "type": "object"
            },
            "description": "\n            The controlnet unions to use for the image generation. Only one controlnet is supported at the moment.\n        ",
            "type": "array"
        },
        "reference_end": {
            "title": "Reference End",
            "default": 1,
            "type": "number",
            "maximum": 1,
            "description": "\n            The percentage of the total timesteps when the reference guidance is to be ended.\n        ",
            "minimum": 0
        },
        "use_cfg_zero": {
            "title": "Use CFG-Zero-Init",
            "default": false,
            "description": "\n            Uses CFG-zero init sampling as in https://arxiv.org/abs/2503.18886.\n        ",
            "type": "boolean"
        },
        "sigma_schedule": {
            "title": "Sigma Schedule",
            "anyOf": [
                {
                    "const": "sgm_uniform",
                    "type": "string"
                },
                {
                    "type": "null"
                }
            ],
            "description": "Sigmas schedule for the denoising process."
        },
        "reference_strength": {
            "title": "Reference Strength",
            "default": 0.65,
            "type": "number",
            "maximum": 3,
            "description": "Strength of reference_only generation. Only used if a reference image is provided.",
            "minimum": -3
        },
        "real_cfg_scale": {
            "title": "Real CFG scale",
            "default": 3.5,
            "type": "number",
            "maximum": 5,
            "description": "\n            The CFG (Classifier Free Guidance) scale is a measure of how close you want\n            the model to stick to your prompt when looking for a related image to show you.\n        ",
            "minimum": 0
        },
        "max_shift": {
            "title": "Max Shift",
            "default": 1.15,
            "type": "number",
            "maximum": 5,
            "description": "Max shift for the scheduled timesteps",
            "minimum": 0.01
        },
        "nag_alpha": {
            "title": "NAG alpha",
            "default": 0.25,
            "exclusiveMinimum": 0,
            "maximum": 1,
            "description": "\n            The alpha value for NAG. This value is used as a final weighting\n            factor for steering the normalized guidance (positive and negative prompts)\n            in the direction of the positive prompt. Higher values will result in less\n            steering on the normalized guidance where lower values will result in\n            considering the positive prompt guidance more.\n        ",
            "type": "number"
        }
    },
    "type": "object"
}
Output (inside result.output) schema · fields, constraints and defaults
ParameterTypeRequiredDefault when omittedDescription / constraints
imagesarrayYes *No documented defaultThe generated image files info.
images[].urlstringYes *No documented default
images[].content_typestring | nullNo"image/jpeg"
images[].heightintegerYes *No documented default
images[].widthintegerYes *No documented default
seedintegerYes *No documented default Seed of the generated Image. It will be the same value of the one passed in the input or the randomly generated that was used in case none was passed.
timingsobjectYes *No documented default
has_nsfw_conceptsarrayYes *No documented defaultWhether the generated images contain NSFW concepts.
promptstringYes *No documented defaultThe prompt used for generating the image.
{
    "title": "Output",
    "required": [
        "images",
        "timings",
        "seed",
        "has_nsfw_concepts",
        "prompt"
    ],
    "x-webot-order-properties": [
        "images",
        "timings",
        "seed",
        "has_nsfw_concepts",
        "prompt"
    ],
    "properties": {
        "images": {
            "title": "Images",
            "items": {
                "title": "Image",
                "required": [
                    "url",
                    "width",
                    "height"
                ],
                "x-webot-order-properties": [
                    "url",
                    "width",
                    "height",
                    "content_type"
                ],
                "properties": {
                    "url": {
                        "title": "Url",
                        "type": "string"
                    },
                    "content_type": {
                        "title": "Content Type",
                        "default": "image/jpeg",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ]
                    },
                    "height": {
                        "title": "Height",
                        "type": "integer"
                    },
                    "width": {
                        "title": "Width",
                        "type": "integer"
                    }
                },
                "type": "object"
            },
            "description": "The generated image files info.",
            "type": "array"
        },
        "seed": {
            "title": "Seed",
            "description": "\n            Seed of the generated Image. It will be the same value of the one passed in the\n            input or the randomly generated that was used in case none was passed.\n        ",
            "type": "integer"
        },
        "timings": {
            "title": "Timings",
            "additionalProperties": {
                "type": "number"
            },
            "type": "object"
        },
        "has_nsfw_concepts": {
            "title": "Has Nsfw Concepts",
            "items": {
                "type": "boolean"
            },
            "description": "Whether the generated images contain NSFW concepts.",
            "type": "array"
        },
        "prompt": {
            "title": "Prompt",
            "description": "The prompt used for generating the image.",
            "type": "string"
        }
    },
    "type": "object"
}
Errors and limits

401 invalid/expired/revoked key · 403 key scope or domain mismatch · 404 unavailable model or unowned request · 409 quote changed, balance, concurrency or idempotency conflict · 413 JSON exceeds 2 MB · 415 wrong content type · 422 invalid fields/media · 429 rate limit · 503 temporary/ambiguous submission. Respect Retry-After. Current limits per account: 12 quotes/submissions, 120 result reads and 8 stream connections per minute. One submission preparation at a time per account. Do not automatically regenerate failed jobs.

Your requests

Flux General - Flux General Differential Diffusion · Your account only

Select Requests to load your history.
Request IDCreated at (IST)StatusCredits usedRefundedProcessing timeReport

Your model analytics

Flux General - Flux General Differential Diffusion · Request dates in IST

Select Analytics to load your metrics.

Total requests
—
Success rate
—
Credits used
—
Processing p50
—

Request counts

Daily requests by their current status

Request outcomes

Completed, failed and pending requests

Credits used

Daily recorded charges before refunds

Processing time

Daily average for completed requests with recorded timing

Processing percentiles

Completed requests only · Time from submission to recorded completion

How to use Flux General Differential Diffusion

Use an existing picture as the starting material. This model changes or processes it according to its specific task and the controls shown here.

Required inputs

  • Prompt: Your instructions to the model. Say what you want, include the important details and avoid contradictory directions. For a video, describe the action as well as the scene.
  • Image URL: The input picture. Use a clear image in one of the accepted formats. If the form offers upload, select a file there; if it asks for a URL, use an accessible HTTPS file link.
  • Change Map URL: The input picture. Use a clear image in one of the accepted formats. If the form offers upload, select a file there; if it asks for a URL, use an accessible HTTPS file link.

Workflow

  1. Prepare your source material and fill the required inputs above. Review the supported settings for this model.
  2. Sign in to calculate the credit estimate. Review the estimate before choosing Generate.
  3. Keep this model page open while the request runs. Completed results arrive in the result area; use the available player or download controls to review the output.

When to use this workflow

  • Work from a photo or illustration you already have.
  • Apply this model’s documented image transformation.

Key settings

Prompt
Your instructions to the model. Say what you want, include the important details and avoid contradictory directions. For a video, describe the action as well as the scene.
Image URL
The input picture. Use a clear image in one of the accepted formats. If the form offers upload, select a file there; if it asks for a URL, use an accessible HTTPS file link.
Change Map URL
The input picture. Use a clear image in one of the accepted formats. If the form offers upload, select a file there; if it asks for a URL, use an accessible HTTPS file link.
Image Size
The output dimensions, usually width and height in pixels or a named size. Pixels are tiny dots that form a picture. More pixels make a larger image; they do not automatically make it more accurate. Choose a size suited to where you will use it. Supported choices: "square_hd", "square", "portrait_4_3", "portrait_16_9", "landscape_4_3", "landscape_16_9"
Width
The horizontal size: how wide the output is, usually in pixels. Changing it can also change the shape or crop. Respect the allowed increments as well as the minimum and maximum. Maximum: 14142. Greater than: 0
Height
The vertical size: how tall the output is, usually in pixels. Width and height together determine the shape and total pixel count. Maximum: 14142. Greater than: 0

Related model workspaces

Product image workflow · Image input choices

Compare more AI models · Explore plans and credits