Venice Image Generation

Two text-to-image endpoints:

1. POST /api/v1/image/generate — Venice-native, full control (negative prompts, CFG, seed, up to 4 variants).
2. POST /api/v1/images/generations — OpenAI-compatible, fewer knobs but drop-in for the OpenAI SDK.

Plus:

• GET /api/v1/image/styles — list of style preset names for style_preset.

For editing / upscaling / multi-image / background removal, see [venice-image-edit](../venice-image-edit/SKILL.md).

Use when

• You need to generate images from text prompts.
• You need multiple variants in one call.
• You're porting from OpenAI's images.generate and want a zero-change SDK swap.
• You want to browse style presets before committing to one.
• You want generated images to match the look of existing images (style_references).

/image/generate — Venice-native

Request

curl https://api.venice.ai/api/v1/image/generate \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "z-image-turbo",
    "prompt": "A beautiful sunset over a mountain range",
    "width": 1024,
    "height": 1024,
    "cfg_scale": 7.5,
    "steps": 8,
    "seed": 123456789,
    "variants": 1,
    "format": "webp",
    "style_preset": "3D Model",
    "safe_mode": true
  }'

Fields

Response (JSON, return_binary: false)

{
  "id": "...",
  "images": ["<base64>", "<base64>"],
  "timing": {...},
  "request": {...}
}

With return_binary: true, response is raw image/webp (or png/jpeg) with matching Content-Type.

/images/generations — OpenAI-compatible

Use this if you're already on the OpenAI SDK. Field names match openai.images.generate().

import OpenAI from 'openai'

const client = new OpenAI({
  apiKey: process.env.VENICE_API_KEY,
  baseURL: 'https://api.venice.ai/api/v1',
})

const res = await client.images.generate({
  model: 'z-image-turbo',
  prompt: 'A beautiful sunset over mountain ranges',
  size: '1024x1024',
  response_format: 'b64_json',
})

const b64 = res.data[0].b64_json

Mapped fields

If you need variants, seed, negativeprompt, cfgscale, stylepreset, or stylereferences, switch to /image/generate.

/image/styles — list presets

curl https://api.venice.ai/api/v1/image/styles \
  -H "Authorization: Bearer $VENICE_API_KEY"

Returns a list of styles[], each with a name you can pass to style_preset. Cache this — it's small and stable.

Choosing a model

curl "https://api.venice.ai/api/v1/models?type=image" \
  -H "Authorization: Bearer $VENICE_API_KEY"

Inspect per-model model_spec:

• constraints.widthHeightDivisor — width and height must both be divisible by this.
• constraints.aspectRatios[] + defaultAspectRatio — if present, the model supports aspect-ratio-driven sizing.
• constraints.resolutions[] + defaultResolution — if present, the model supports resolution (1K/2K/4K).
• constraints.steps.{default,max} — step bounds (some models ignore steps entirely).
• constraints.promptCharacterLimit — max prompt length (also applies to negative_prompt).
• supportsStyleReferences — whether the model accepts style_references on /image/generate.
• constraints.maxStyleReferences — max number of style reference images (only present on supporting models).
• constraints.supportsStyleReferenceStrength — whether per-reference strength is honored (only present on supporting models).
• pricing.generation.usd — flat USD per image, or pricing.resolutions[].usd for resolution-tiered models.

Pick a model that matches the feature + size combo you plan to use.

Common patterns

Fixed-seed A/B test

{"model": "z-image-turbo", "prompt": "...", "seed": 42, "variants": 4}

Aspect-ratio-driven model (Nano Banana family)

{"model": "nano-banana-2", "prompt": "...", "aspect_ratio": "16:9", "resolution": "2K"}

(Other nano-banana variants: nano-banana-pro. Always verify the current ID via GET /models?type=image.)

Style preset + negative

{
  "model": "z-image-turbo",
  "prompt": "a red sports car in a parking lot",
  "negative_prompt": "blurry, people, clouds",
  "style_preset": "3D Model"
}

Style references (match the look of existing images)

{
  "model": "krea-v2-large",
  "prompt": "a lighthouse on a rocky coast at dusk",
  "style_references": [
    { "image": "https://example.com/ref-1.png", "strength": 0.8 },
    { "image": "data:image/png;base64,....", "strength": 0.4 }
  ]
}

Describe the subject in the prompt; the references carry the style. As of mid-2026 the supporting models are krea-v2-large / krea-v2-medium (up to 3 refs, strength honored) and luma-uni-1 / luma-uni-1-max (up to 3 refs, strength ignored) — all anonymized routing. Always re-verify via GET /models?type=image (supportsStyleReferences).

Stream binary to disk (Node)

const res = await fetch('https://api.venice.ai/api/v1/image/generate', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.VENICE_API_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ model: 'z-image-turbo', prompt: '...', return_binary: true }),
})
if (!res.ok) throw new Error(await res.text())
const buf = Buffer.from(await res.arrayBuffer())
await fs.writeFile('out.webp', buf)

Errors

(Content-policy violations on /image/generate come back as 400 with an error string, not 422 — the 422 shape is specific to audio generation paths.)

Gotchas

• Each model picks one sizing idiom: either width/height, aspect_ratio + resolution, or (OpenAI-compat) size. Match the model's constraints.
• variants > 1 requires return_binary: false (JSON with base64 array).
• steps is ignored by fast/turbo models; they hardcode step count internally.
• hide_watermark: true is advisory — Venice may still watermark content flagged by safety classifiers.
• Old inpaint field is deprecated; don't use it.
• style_references is silently unsupported outside the models flagged supportsStyleReferences: true; check the flag rather than trying and inspecting output. Each reference image must be < 8MB.
• For OpenAI-compat, response_format: "url" returns a data URL, not a hosted URL — plan for that if you're saving to storage.