Bria Fibo Bbq Preview — Generate

Bria Fibo Bbq Preview — Generate.

Input

Add your inputs and customize the generation settings.

Prompt for image generation.
Upload, drag and drop, or paste a public HTTPS URL.
Selected image

Reference image (file or URL).

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) per generated image

SpecificationWebot INR
Rate₹4.79
Calculate credits in the input panel for your selected settings.

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

Prices are converted to INR. Credits use your current plan rate.

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

API

WEBOT API · Generate

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/bria_fibo_bbq_preview_generate/quoteValidate input and calculate credits (no deduction).
POSThttps://webot.online/api/v1/models/bria_fibo_bbq_preview_generate/requestsReserve quoted credits and queue an asynchronous job.
GEThttps://webot.online/api/v1/models/bria_fibo_bbq_preview_generate/requests/{request_id}/resultRead your saved result: 202 pending, 200 terminal.
GEThttps://webot.online/api/v1/models/bria_fibo_bbq_preview_generate/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.

{
    "steps_num": 50,
    "aspect_ratio": "1:1",
    "sync_mode": false,
    "guidance_scale": 5,
    "seed": 5555,
    "negative_prompt": ""
}
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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote', {input});
const job = await post('/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote', {input});
const job = await post('/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote', {'input': input_data})['quote']
job = post('/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote', ['input'=>$input])['quote'];
$job = post('/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote",map[string]any{"input":input},"")["quote"].(map[string]any)
    job:=post("/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/quote', {'input' => input})['quote']
nonce = ENV['WEBOT_JOB_NONCE'] || SecureRandom.uuid # Persist this before submission.
job = post.call('/api/v1/models/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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/bria_fibo_bbq_preview_generate/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
promptstring | nullNoNo documented defaultPrompt for image generation.
steps_numintegerNo50Number of inference steps.
minimum: 20 · maximum: 50
aspect_ratiostringNo"1:1"Aspect ratio. Options: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9
enum: ["1:1","2:3","3:2","3:4","4:3","4:5","5:4","9:16","16:9"]
image_urlstring | nullNoNo documented defaultReference image (file or URL).
sync_modebooleanNofalseIf true, returns the image directly in the response (increases latency).
guidance_scaleintegerNo5Guidance scale for text.
minimum: 3 · maximum: 5
seedintegerNo5555Random seed for reproducibility.
negative_promptstringNo""Negative prompt for image generation.
structured_promptobject | string | nullNoNo documented defaultThe structured prompt to generate an image from.
structured_prompt.variant0.background_settingstring | nullNoNo documented defaultThe background setting of the image to be generated.
structured_prompt.variant0.artistic_stylestring | nullNoNo documented defaultThe artistic style of the image to be generated.
structured_prompt.variant0.style_mediumstring | nullNoNo documented defaultThe style medium of the image to be generated.
structured_prompt.variant0.text_renderarray | nullNo[]A list of text to be rendered in the image.
structured_prompt.variant0.objectsarray | nullNo[]A list of objects in the image to be generated, along with their attributes and relationships to other objects in the image.
structured_prompt.variant0.aestheticsobject | nullNoNo documented defaultThe aesthetics of the image to be generated.
structured_prompt.variant0.aesthetics.variant0.preference_scorestring | nullNoNo documented defaultThe preference score of the image (e.g., 'very high', 'high', 'medium', 'low').
structured_prompt.variant0.aesthetics.variant0.compositionstring | nullNoNo documented defaultThe composition of the image to be generated.
structured_prompt.variant0.aesthetics.variant0.mood_atmospherestring | nullNoNo documented defaultThe mood and atmosphere of the image to be generated.
structured_prompt.variant0.aesthetics.variant0.aesthetic_scorestring | nullNoNo documented defaultThe aesthetic score of the image (e.g., 'very high', 'high', 'medium', 'low').
structured_prompt.variant0.aesthetics.variant0.color_schemestring | nullNoNo documented defaultThe color scheme of the image to be generated.
structured_prompt.variant0.photographic_characteristicsobject | nullNoNo documented defaultThe photographic characteristics of the image to be generated.
structured_prompt.variant0.photographic_characteristics.variant0.focusstring | nullNoNo documented defaultThe focus in the image to be generated.
structured_prompt.variant0.photographic_characteristics.variant0.lens_focal_lengthstring | nullNoNo documented defaultThe focal length of the lens in the image to be generated.
structured_prompt.variant0.photographic_characteristics.variant0.camera_anglestring | nullNoNo documented defaultThe angle of the camera in the image to be generated.
structured_prompt.variant0.photographic_characteristics.variant0.depth_of_fieldstring | nullNoNo documented defaultThe depth of field in the image to be generated.
structured_prompt.variant0.contextstring | nullNoNo documented defaultThe context of the image to be generated.
structured_prompt.variant0.lightingobject | nullNoNo documented defaultThe lighting of the image to be generated.
structured_prompt.variant0.lighting.variant0.shadowsstring | nullNoNo documented defaultThe shadows in the image to be generated.
structured_prompt.variant0.lighting.variant0.conditionsstring | nullNoNo documented defaultThe conditions of the lighting in the image to be generated.
structured_prompt.variant0.lighting.variant0.directionstring | nullNoNo documented defaultThe direction of the lighting in the image to be generated.
structured_prompt.variant0.color_palettearray | nullNoNo documented defaultA list of colors that define the overall color palette of the image.
structured_prompt.variant0.short_descriptionstring | nullNoNo documented defaultA short description of the image to be generated.
{
    "title": "GaiaInputModel",
    "type": "object",
    "properties": {
        "prompt": {
            "examples": [
                "A hyper-detailed, ultra-fluffy owl sitting in the trees at night, looking directly at the camera with wide, adorable, expressive eyes. Its feathers are soft and voluminous, catching the cool moonlight with subtle silver highlights. The owl's gaze is curious and full of charm, giving it a whimsical, storybook-like personality."
            ],
            "description": "Prompt for image generation.",
            "title": "Prompt",
            "anyOf": [
                {
                    "type": "string"
                },
                {
                    "type": "null"
                }
            ]
        },
        "steps_num": {
            "description": "Number of inference steps.",
            "type": "integer",
            "minimum": 20,
            "maximum": 50,
            "title": "Steps Num",
            "default": 50
        },
        "aspect_ratio": {
            "enum": [
                "1:1",
                "2:3",
                "3:2",
                "3:4",
                "4:3",
                "4:5",
                "5:4",
                "9:16",
                "16:9"
            ],
            "description": "Aspect ratio. Options: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9",
            "type": "string",
            "title": "Aspect Ratio",
            "default": "1:1"
        },
        "image_url": {
            "anyOf": [
                {
                    "type": "string"
                },
                {
                    "type": "null"
                }
            ],
            "title": "Image Url",
            "description": "Reference image (file or URL)."
        },
        "sync_mode": {
            "description": "If true, returns the image directly in the response (increases latency).",
            "type": "boolean",
            "title": "Sync Mode",
            "default": false
        },
        "guidance_scale": {
            "description": "Guidance scale for text.",
            "type": "integer",
            "minimum": 3,
            "maximum": 5,
            "title": "Guidance Scale",
            "default": 5
        },
        "seed": {
            "description": "Random seed for reproducibility.",
            "type": "integer",
            "title": "Seed",
            "default": 5555
        },
        "negative_prompt": {
            "description": "Negative prompt for image generation.",
            "type": "string",
            "title": "Negative Prompt",
            "default": ""
        },
        "structured_prompt": {
            "anyOf": [
                {
                    "title": "StructuredPrompt",
                    "type": "object",
                    "properties": {
                        "background_setting": {
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Background Setting",
                            "description": "The background setting of the image to be generated."
                        },
                        "artistic_style": {
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Artistic Style",
                            "description": "The artistic style of the image to be generated."
                        },
                        "style_medium": {
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Style Medium",
                            "description": "The style medium of the image to be generated."
                        },
                        "text_render": {
                            "anyOf": [
                                {
                                    "type": "array",
                                    "items": {}
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Text Render",
                            "description": "A list of text to be rendered in the image.",
                            "default": []
                        },
                        "objects": {
                            "anyOf": [
                                {
                                    "type": "array",
                                    "items": {
                                        "title": "PromptObject",
                                        "type": "object",
                                        "properties": {
                                            "skin_color": {
                                                "anyOf": [
                                                    {
                                                        "title": "Color",
                                                        "type": "object",
                                                        "properties": {
                                                            "blue": {
                                                                "title": "Blue",
                                                                "type": "integer",
                                                                "description": "The blue component of the color (0-255)."
                                                            },
                                                            "green": {
                                                                "title": "Green",
                                                                "type": "integer",
                                                                "description": "The green component of the color (0-255)."
                                                            },
                                                            "red": {
                                                                "title": "Red",
                                                                "type": "integer",
                                                                "description": "The red component of the color (0-255)."
                                                            },
                                                            "name": {
                                                                "anyOf": [
                                                                    {
                                                                        "type": "string"
                                                                    },
                                                                    {
                                                                        "type": "null"
                                                                    }
                                                                ],
                                                                "title": "Name",
                                                                "description": "The name of the color."
                                                            }
                                                        },
                                                        "x-webot-order-properties": [
                                                            "name",
                                                            "red",
                                                            "green",
                                                            "blue"
                                                        ],
                                                        "required": [
                                                            "red",
                                                            "green",
                                                            "blue"
                                                        ]
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "description": "The RGB color values for the skin tone of the object."
                                            },
                                            "description": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Description",
                                                "description": "A description of the object to be generated."
                                            },
                                            "clothing": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Clothing",
                                                "description": "The clothing of the object in the image."
                                            },
                                            "orientation": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Orientation",
                                                "description": "The orientation of the object in the image."
                                            },
                                            "colors": {
                                                "anyOf": [
                                                    {
                                                        "type": "array",
                                                        "items": {
                                                            "title": "Color",
                                                            "type": "object",
                                                            "properties": {
                                                                "blue": {
                                                                    "title": "Blue",
                                                                    "type": "integer",
                                                                    "description": "The blue component of the color (0-255)."
                                                                },
                                                                "green": {
                                                                    "title": "Green",
                                                                    "type": "integer",
                                                                    "description": "The green component of the color (0-255)."
                                                                },
                                                                "red": {
                                                                    "title": "Red",
                                                                    "type": "integer",
                                                                    "description": "The red component of the color (0-255)."
                                                                },
                                                                "name": {
                                                                    "anyOf": [
                                                                        {
                                                                            "type": "string"
                                                                        },
                                                                        {
                                                                            "type": "null"
                                                                        }
                                                                    ],
                                                                    "title": "Name",
                                                                    "description": "The name of the color."
                                                                }
                                                            },
                                                            "x-webot-order-properties": [
                                                                "name",
                                                                "red",
                                                                "green",
                                                                "blue"
                                                            ],
                                                            "required": [
                                                                "red",
                                                                "green",
                                                                "blue"
                                                            ]
                                                        }
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Colors",
                                                "description": "A list of colors associated with the object."
                                            },
                                            "skin_tone_and_texture": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Skin Tone And Texture",
                                                "description": "The skin tone and texture of the object in the image."
                                            },
                                            "appearance_details": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Appearance Details",
                                                "description": "The appearance details of the object."
                                            },
                                            "number_of_objects": {
                                                "anyOf": [
                                                    {
                                                        "type": "integer"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Number Of Objects",
                                                "description": "The number of objects in the image."
                                            },
                                            "relative_distance": {
                                                "anyOf": [
                                                    {
                                                        "type": "number"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Relative Distance",
                                                "description": "The relative distance of the object from the camera or viewer."
                                            },
                                            "expression": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Expression",
                                                "description": "The expression of the object in the image."
                                            },
                                            "pose": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Pose",
                                                "description": "The pose of the object in the image."
                                            },
                                            "shape_and_color": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Shape And Color",
                                                "description": "The shape and color of the object."
                                            },
                                            "relationship": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Relationship",
                                                "description": "The relationship of the object to other objects in the image."
                                            },
                                            "texture": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Texture",
                                                "description": "The texture of the object."
                                            },
                                            "gender": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Gender",
                                                "description": "The gender of the object in the image."
                                            },
                                            "relative_size": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Relative Size",
                                                "description": "The relative size of the object in the image."
                                            },
                                            "location": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Location",
                                                "description": "The location of the object in the image."
                                            },
                                            "bounding_boxes": {
                                                "anyOf": [
                                                    {
                                                        "type": "array",
                                                        "items": {
                                                            "title": "BoundingBox",
                                                            "type": "object",
                                                            "properties": {
                                                                "bottom_right": {
                                                                    "title": "Point",
                                                                    "type": "object",
                                                                    "properties": {
                                                                        "y": {
                                                                            "title": "Y",
                                                                            "type": "number",
                                                                            "description": "The y coordinate."
                                                                        },
                                                                        "x": {
                                                                            "title": "X",
                                                                            "type": "number",
                                                                            "description": "The x coordinate."
                                                                        }
                                                                    },
                                                                    "x-webot-order-properties": [
                                                                        "x",
                                                                        "y"
                                                                    ],
                                                                    "required": [
                                                                        "x",
                                                                        "y"
                                                                    ],
                                                                    "description": "The bottom-right corner of the bounding box."
                                                                },
                                                                "top_left": {
                                                                    "title": "Point",
                                                                    "type": "object",
                                                                    "properties": {
                                                                        "y": {
                                                                            "title": "Y",
                                                                            "type": "number",
                                                                            "description": "The y coordinate."
                                                                        },
                                                                        "x": {
                                                                            "title": "X",
                                                                            "type": "number",
                                                                            "description": "The x coordinate."
                                                                        }
                                                                    },
                                                                    "x-webot-order-properties": [
                                                                        "x",
                                                                        "y"
                                                                    ],
                                                                    "required": [
                                                                        "x",
                                                                        "y"
                                                                    ],
                                                                    "description": "The top-left corner of the bounding box."
                                                                }
                                                            },
                                                            "x-webot-order-properties": [
                                                                "top_left",
                                                                "bottom_right"
                                                            ],
                                                            "required": [
                                                                "top_left",
                                                                "bottom_right"
                                                            ]
                                                        }
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Bounding Boxes",
                                                "description": "Bounding boxes defining the location of the object in the image."
                                            },
                                            "action": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Action",
                                                "description": "The action of the object in the image."
                                            }
                                        },
                                        "x-webot-order-properties": [
                                            "description",
                                            "bounding_boxes",
                                            "colors",
                                            "location",
                                            "relationship",
                                            "relative_size",
                                            "shape_and_color",
                                            "texture",
                                            "appearance_details",
                                            "number_of_objects",
                                            "pose",
                                            "expression",
                                            "clothing",
                                            "action",
                                            "gender",
                                            "skin_tone_and_texture",
                                            "skin_color",
                                            "orientation",
                                            "relative_distance"
                                        ]
                                    }
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Objects",
                            "description": "A list of objects in the image to be generated, along with their attributes and relationships to other objects in the image.",
                            "default": []
                        },
                        "aesthetics": {
                            "anyOf": [
                                {
                                    "title": "Aesthetics",
                                    "type": "object",
                                    "properties": {
                                        "preference_score": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Preference Score",
                                            "description": "The preference score of the image (e.g., 'very high', 'high', 'medium', 'low')."
                                        },
                                        "composition": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Composition",
                                            "description": "The composition of the image to be generated."
                                        },
                                        "mood_atmosphere": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Mood Atmosphere",
                                            "description": "The mood and atmosphere of the image to be generated."
                                        },
                                        "aesthetic_score": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Aesthetic Score",
                                            "description": "The aesthetic score of the image (e.g., 'very high', 'high', 'medium', 'low')."
                                        },
                                        "color_scheme": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Color Scheme",
                                            "description": "The color scheme of the image to be generated."
                                        }
                                    },
                                    "additionalProperties": true,
                                    "x-webot-order-properties": [
                                        "composition",
                                        "color_scheme",
                                        "mood_atmosphere",
                                        "aesthetic_score",
                                        "preference_score"
                                    ]
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "description": "The aesthetics of the image to be generated."
                        },
                        "photographic_characteristics": {
                            "anyOf": [
                                {
                                    "title": "PhotographicCharacteristics",
                                    "type": "object",
                                    "properties": {
                                        "focus": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Focus",
                                            "description": "The focus in the image to be generated."
                                        },
                                        "lens_focal_length": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Lens Focal Length",
                                            "description": "The focal length of the lens in the image to be generated."
                                        },
                                        "camera_angle": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Camera Angle",
                                            "description": "The angle of the camera in the image to be generated."
                                        },
                                        "depth_of_field": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Depth Of Field",
                                            "description": "The depth of field in the image to be generated."
                                        }
                                    },
                                    "additionalProperties": true,
                                    "x-webot-order-properties": [
                                        "depth_of_field",
                                        "focus",
                                        "camera_angle",
                                        "lens_focal_length"
                                    ]
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "description": "The photographic characteristics of the image to be generated."
                        },
                        "context": {
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Context",
                            "description": "The context of the image to be generated."
                        },
                        "lighting": {
                            "anyOf": [
                                {
                                    "title": "Lighting",
                                    "type": "object",
                                    "properties": {
                                        "shadows": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Shadows",
                                            "description": "The shadows in the image to be generated."
                                        },
                                        "conditions": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Conditions",
                                            "description": "The conditions of the lighting in the image to be generated."
                                        },
                                        "direction": {
                                            "anyOf": [
                                                {
                                                    "type": "string"
                                                },
                                                {
                                                    "type": "null"
                                                }
                                            ],
                                            "title": "Direction",
                                            "description": "The direction of the lighting in the image to be generated."
                                        }
                                    },
                                    "additionalProperties": true,
                                    "x-webot-order-properties": [
                                        "conditions",
                                        "direction",
                                        "shadows"
                                    ]
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "description": "The lighting of the image to be generated."
                        },
                        "color_palette": {
                            "anyOf": [
                                {
                                    "type": "array",
                                    "items": {
                                        "title": "Color",
                                        "type": "object",
                                        "properties": {
                                            "blue": {
                                                "title": "Blue",
                                                "type": "integer",
                                                "description": "The blue component of the color (0-255)."
                                            },
                                            "green": {
                                                "title": "Green",
                                                "type": "integer",
                                                "description": "The green component of the color (0-255)."
                                            },
                                            "red": {
                                                "title": "Red",
                                                "type": "integer",
                                                "description": "The red component of the color (0-255)."
                                            },
                                            "name": {
                                                "anyOf": [
                                                    {
                                                        "type": "string"
                                                    },
                                                    {
                                                        "type": "null"
                                                    }
                                                ],
                                                "title": "Name",
                                                "description": "The name of the color."
                                            }
                                        },
                                        "x-webot-order-properties": [
                                            "name",
                                            "red",
                                            "green",
                                            "blue"
                                        ],
                                        "required": [
                                            "red",
                                            "green",
                                            "blue"
                                        ]
                                    }
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Color Palette",
                            "description": "A list of colors that define the overall color palette of the image."
                        },
                        "short_description": {
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ],
                            "title": "Short Description",
                            "description": "A short description of the image to be generated."
                        }
                    },
                    "x-webot-order-properties": [
                        "short_description",
                        "objects",
                        "color_palette",
                        "background_setting",
                        "lighting",
                        "aesthetics",
                        "photographic_characteristics",
                        "style_medium",
                        "text_render",
                        "context",
                        "artistic_style"
                    ]
                },
                {
                    "type": "string"
                },
                {
                    "additionalProperties": true,
                    "type": "object"
                },
                {
                    "type": "null"
                }
            ],
            "title": "Structured Prompt",
            "description": "The structured prompt to generate an image from."
        }
    },
    "x-webot-order-properties": [
        "prompt",
        "aspect_ratio",
        "structured_prompt",
        "image_url",
        "seed",
        "steps_num",
        "negative_prompt",
        "guidance_scale",
        "sync_mode"
    ]
}
Output (inside result.output) schema · fields, constraints and defaults
ParameterTypeRequiredDefault when omittedDescription / constraints
imagesarrayNoNo documented defaultGenerated images.
imageobjectYes *No documented defaultGenerated image.
image.file_sizeinteger | nullNoNo documented defaultThe size of the file in bytes.
image.heightinteger | nullNoNo documented defaultThe height of the image in pixels.
image.file_namestring | nullNoNo documented defaultThe name of the file. It will be auto-generated if not provided.
image.content_typestring | nullNoNo documented defaultThe mime type of the file.
image.urlstringYes *No documented defaultThe URL where the file can be downloaded from.
image.widthinteger | nullNoNo documented defaultThe width of the image in pixels.
structured_promptobjectYes *No documented defaultCurrent prompt.
{
    "title": "GaiaOutputModel",
    "type": "object",
    "properties": {
        "images": {
            "title": "Images",
            "type": "array",
            "description": "Generated images.",
            "items": {
                "additionalProperties": true,
                "type": "object"
            }
        },
        "image": {
            "description": "Generated image.",
            "type": "object",
            "x-webot-order-properties": [
                "url",
                "content_type",
                "file_name",
                "file_size",
                "width",
                "height"
            ],
            "title": "Image",
            "properties": {
                "file_size": {
                    "examples": [
                        4404019
                    ],
                    "title": "File Size",
                    "description": "The size of the file in bytes.",
                    "anyOf": [
                        {
                            "type": "integer"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "height": {
                    "examples": [
                        1024
                    ],
                    "title": "Height",
                    "description": "The height of the image in pixels.",
                    "anyOf": [
                        {
                            "type": "integer"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "file_name": {
                    "examples": [
                        "z9RV14K95DvU.png"
                    ],
                    "title": "File Name",
                    "description": "The name of the file. It will be auto-generated if not provided.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "content_type": {
                    "examples": [
                        "image/png"
                    ],
                    "title": "Content Type",
                    "description": "The mime type of the file.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "url": {
                    "title": "Url",
                    "type": "string",
                    "description": "The URL where the file can be downloaded from."
                },
                "width": {
                    "examples": [
                        1024
                    ],
                    "title": "Width",
                    "description": "The width of the image in pixels.",
                    "anyOf": [
                        {
                            "type": "integer"
                        },
                        {
                            "type": "null"
                        }
                    ]
                }
            },
            "required": [
                "url"
            ]
        },
        "structured_prompt": {
            "additionalProperties": true,
            "type": "object",
            "title": "Structured Prompt",
            "description": "Current prompt."
        }
    },
    "x-webot-order-properties": [
        "image",
        "images",
        "structured_prompt"
    ],
    "required": [
        "image",
        "structured_prompt"
    ]
}
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

Bria Fibo Bbq Preview - Generate · Your account only

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

Your model analytics

Bria Fibo Bbq Preview - Generate · 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 Bria Fibo Bbq Preview — Generate

Describe a picture in words. This model generates an image from your description; you do not need to draw it yourself.

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

  • Create an illustration, concept or product scene.
  • Explore different visual styles for an idea.

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.
Aspect Ratio
The shape of the picture: width compared with height. 16:9 is wide, 9:16 is tall for phone screens, and 1:1 is square. This changes the shape, not the sharpness by itself. Only this model’s listed ratios are supported. Supported choices: "1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9"
Structured Prompt
A prompt divided into named parts, such as subject, setting and lighting. This makes the instructions more explicit; keep all parts consistent with each other.
Background Setting
The requested background or its colour, where this tool supports changing it. A colour value chooses a flat colour; transparent output also needs a format that supports transparency.
Artistic Style
A detailed visual instruction within the structured prompt. It describes this part of the scene, such as layout, lighting, mood or the objects to include. Keep it consistent with the main prompt.
Style Medium
A named visual or sound style. It changes the overall feel, such as a photographic or illustrated look when those choices are supported. It does not change the subject by itself.

Related model workspaces

Product image workflow · Image input choices

Compare more AI models · Explore plans and credits