Bria 3.2 is a commercial-ready text-to-image model with 4B parameters, delivering exceptional aesthetics and accurate text rendering. Ready-to-use REST inference API, no coldstarts, best performance, affordable pricing.
Idle

$0.04per run·~25 / $1

Extreme close-up macro photograph of a dragonfly's wing resting on a leaf. Intricate, iridescent geometric patterns of the wing are visible, with tiny morning dew drops clinging to the surface, refracting light like tiny prisms. The leaf is a vibrant green with sharp veins. Hyper-detailed, photorealistic, shallow depth of field, bokeh.

Hummingbird hovering near a blooming flower

Butterfly resting on a wet leaf

A classic film noir scene. A lone, hard-boiled detective in a fedora and trench coat stands in a dimly lit, smoke-filled office. Blinds on the window cast stark, dramatic shadows across the room. Rain streaks down the glass, reflecting a flickering neon sign from outside. Moody, high contrast, black and white (or desaturated color), cinematic, 1940s aesthetic.

A biopunk laboratory where nature and technology have merged. A scientist studies a giant, translucent plant specimen that glows with an internal, pulsating blue light. Walls are made of living, bioluminescent fungus, and intricate root systems serve as data cables. Eerie, organic, futuristic, detailed, 'Annihilation' inspired.

A surreal vaporwave dreamscape. A classic marble statue stands in a pool of pink, reflective water. The background is a digital grid landscape under a purple-pink gradient sky, with a low-resolution sun setting. Floating geometric shapes and digital artifacts drift by. Aesthetic, retro, 80s computer graphics, nostalgic, lo-fi.

An ancient, gothic university library at night, lit only by candlelight and moonlight. Towering shelves filled with leather-bound books reach a vaulted ceiling. A student sits at a heavy oak desk, poring over an old manuscript. Dust motes dance in the beams of moonlight. Atmospheric, moody, scholarly, dark academia, mysterious.

Full-body concept art of a plague doctor druid. They wear a long, dark robe made of stitched-together leaves and bark, and a classic beaked mask carved from pale wood. A gnarled wooden staff, glowing with faint green energy, is held in their gloved hand. A belt holds various pouches and glowing vials. Fantasy, character design sheet, detailed, isolated on white background.

A street-level view of a gritty, towering Dieselpunk city, dominated by massive brass and iron structures inspired by Art Deco architecture. A colossal zeppelin, bristling with machinery, is moored to a skyscraper. The air is thick with smoke and smog, lit by harsh spotlights. Gritty, industrial, 1930s aesthetic, high contrast, cinematic.

A panoramic view of a bioluminescent underwater city encased in massive, interconnected glass domes on the ocean floor. Sleek, manta-ray-shaped submarines glide between structures. Giant, glowing jellyfish and schools of exotic fish swim past, while deep ocean trenches loom in the dark, mysterious background. Utopian, futuristic, aquatic, detailed, glowing.
Bria T2I 3.2 turns text prompts into high-quality images with reliable composition, strong detail, and style control. It supports negative prompts, a wide range of aspect ratios, deterministic seed control, and API options for sync and BASE64 output. Trained on licensed data for compliant commercial use.
prompt* (string, required) Describe subject, setting, lighting, lens/camera, materials, and style. Example: “Macro shot of a butterfly wing with dew drops, photorealistic, shallow depth of field, bokeh.”
aspect_ratio (dropdown) Canvas proportion. Options include: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9.
negative_prompt (string, optional) Traits to avoid (e.g., “blurry, artifact, extra fingers, watermark, text”).
seed (integer, optional) Controls randomness. Same prompt + params + seed ⇒ same image. -1 uses a random seed (click the refresh icon in the UI to randomize).
Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/bria/text-to-image-3.2 with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Text To Image 3.2 below.
set -euo pipefail
: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"
REQUEST_BODY=$(cat <<'JSON'
{
"prompt": "A cinematic shot of a city at sunset, soft golden light",
"aspect_ratio": "1:1"
}
JSON
)
# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
-X POST "https://api.wavespeed.ai/api/v3/bria/text-to-image-3.2" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $WAVESPEED_API_KEY" \
-d "$REQUEST_BODY")
TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
printf 'Submission response did not contain a prediction id
' >&2
exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"
# 2. Poll until the prediction finishes.
while true; do
RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
-H "Authorization: Bearer $WAVESPEED_API_KEY")
RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
case "$STATUS" in
completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
*) sleep 2 ;;
esac
doneconst submitUrl = "https://api.wavespeed.ai/api/v3/bria/text-to-image-3.2";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');
async function requestJson(url, options = {}) {
const response = await fetch(url, options);
if (!response.ok) throw new Error(await response.text());
return response.json();
}
// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
"prompt": "A cinematic shot of a city at sunset, soft golden light",
"aspect_ratio": "1:1"
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;
// 2. Poll until the prediction finishes.
while (true) {
const resultBody = await requestJson(resultUrl, {
headers: { "Authorization": `Bearer ${apiKey}` },
});
const result = resultBody.data ?? resultBody;
if (result.status === "completed") {
console.log(result.outputs);
break;
}
if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
await new Promise(resolve => setTimeout(resolve, 2000));
}import json
import os
import time
from urllib.request import Request, urlopen
api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
"prompt": "A cinematic shot of a city at sunset, soft golden light",
"aspect_ratio": "1:1"
}
def request_json(url, data=None):
request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
with urlopen(request) as response:
return json.load(response)
# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/bria/text-to-image-3.2", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"
# 2. Poll until the prediction finishes.
while True:
result_body = request_json(result_url)
result = result_body.get("data", result_body)
status = result.get("status")
if status == "completed":
print(result.get("outputs", []))
break
if status in {"failed", "cancelled", "timeout", "deleted"}:
raise RuntimeError(result)
time.sleep(2)Text To Image 3.2 is a Bria model for image generation, exposed as a REST API on WaveSpeedAI. Bria 3.2 is a commercial-ready text-to-image model with 4B parameters, delivering exceptional aesthetics and accurate text rendering. Ready-to-use REST inference API, no coldstarts, best performance, affordable pricing. You can call it programmatically or try it from the playground above.
POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates production-oriented Python, JavaScript, and cURL examples with timeouts, transient-error handling, and safe GET retries. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/bria/bria-text-to-image-3.2.
Text To Image 3.2 starts at $0.040 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.
Key inputs: `prompt`, `aspect_ratio`, `seed`, `negative_prompt`, `enable_base64_output`, `enable_sync_mode`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/bria/bria-text-to-image-3.2.
Median end-to-end generation time on WaveSpeedAI is around 16 seconds per request, based on recent successful runs. Queue time varies with global demand; live status is visible in the prediction record.
Commercial usage rights depend on the model's license, set by its provider (Bria). The license summary appears on the model card above; see WaveSpeedAI's Terms of Service for platform-level conditions.