> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Opprett et bilde
> Bruk CometAPI POST /v1/images/generations til å opprette bilder med OpenAI-kompatible bildemodeller og modellspesifikke kontroller.
Bruk denne ruten til å opprette bilder fra tekst med OpenAI-kompatible forespørselsformater på CometAPI.
## Offisiell referanse
* Les [OpenAIs veiledning for bildegenerering](https://developers.openai.com/api/docs/guides/image-generation) før du tar i bruk modellspesifikke kontroller som `background`, `output_compression`, streaming eller fremtidige GPT-bildealternativer.
* Bruk [OpenAI-referansen for å opprette bilder](https://developers.openai.com/api/reference/resources/images/methods/generate) for den gjeldende parameterlisten.
## Velg først en modell
* Bruk en GPT-bildemodell som `gpt-image-2` for tekst-til-bilde-forespørsler med kontroller som `output_format`, `quality` eller `background`
* Bruk `gpt-image-2.5-sunburst` eller `gpt-image-2.5-flare` når du trenger gjennomsiktige bakgrunner eller kvalitetsnivåene `xhigh` og `max`
* Bruk `qwen-image` når du spesifikt trenger den leverandøren, men behold `n` på 1
* Velg en gjeldende bilde-ID fra [Models-siden](/no/overview/models)
## Trygg første forespørsel
* Start med `gpt-image-2`
* Behold `size` på `1024x1024`
* GPT-bildemodeller returnerer base64-kodede bildedata i `b64_json`; dekod dem for å lagre bildefilen
* Legg til `output_format` bare når du trenger en bestemt kodet bildetype, for eksempel `jpeg`
* Bruk én Prompt og ett utdata-bilde før du legger til batchgenerering eller stiljustering
## Kjør en asynkron bildeoppgave
Bruk `async: true` for langvarige bildejobber når klienten din foretrekker en send-og-poll-flyt fremfor å holde én HTTP-tilkobling åpen. Opprettelsesforespørselen returnerer `data.task_id`.
Poll [Hent en bildegenereringsoppgave](/no/api/image/openai/image-generation-task) til `data.status` er `success` eller `failure`.
Feltet `async` er en CometAPI-utvidelse for denne ruten, ikke en OpenAI-parameter. OpenAI dokumenterer `stream` og `partial_images` for GPT-bildemodeller. CometAPI-modus for asynkrone oppgaver returnerer JSON-oppgavemetadata og bruker polling.
Bruk modus for asynkrone oppgaver med disse dokumenterte modell-ID-ene: `gpt-image-2` og `doubao-seedream-4-0-250828`. For andre bildemodeller bruker du synkron generering eller streaming med mindre støtte for asynkrone oppgaver er dokumentert for den modellen.
Når en forespørsel inkluderer både `async: true` og `stream: true`, har modus for asynkrone oppgaver forrang. Opprettelsesforespørselen returnerer JSON-oppgavemetadata i stedet for en SSE-strøm.
## Modellspesifikk forespørselsatferd
* `response_format` gjelder bare DALL·E-modeller; GPT-bildemodeller returnerer base64-data og ignorerer den
* GPT-bildemodeller bruker GPT-only-kontroller som `output_format`, `quality`, `background` og `output_compression`
* `quality` godtar `low`, `medium`, `high` og `auto` for GPT-bildemodeller; `gpt-image-2.5-sunburst` og `gpt-image-2.5-flare` godtar også `xhigh` og `max`
* `output_compression` gjelder når `output_format` er `webp` eller `jpeg`; den har ingen effekt på `png`
* `partial_images` gjelder bare når `stream` er `true`
* Følg OpenAIs veiledning for bildegenerering for de nyeste modellspesifikke alternativene
* `qwen-image` støtter ikke `n > 1`
## Generer en gjennomsiktig bakgrunn
Angi `background` til `transparent` for å generere et isolert motiv uten bakgrunnsfyll. Dette støttes av `gpt-image-2.5-sunburst` og `gpt-image-2.5-flare`.
Gjennomsiktighet krever et utdataformat med en alfakanal. Angi `output_format` til `png` eller `webp`. JPEG har ingen alfakanal, så en forespørsel om gjennomsiktighet med `output_format: "jpeg"` avvises.
Svaret returnerer base64-bildedata i `b64_json` med en alfakanal. Dekod dem for å lagre filen:
```python theme={null}
import base64
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.cometapi.com/v1",
api_key=os.environ["COMETAPI_KEY"],
)
result = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt="A single red apple, centered, isolated subject.",
quality="low",
size="1024x1024",
background="transparent",
output_format="png",
)
with open("apple.png", "wb") as f:
f.write(base64.b64decode(result.data[0].b64_json))
```
Angi `background` til `opaque` for å tvinge frem en ensfarget bakgrunn, eller `auto` for å la modellen avgjøre. Svaret gjengir den anvendte verdien i feltet `background` på toppnivå.
Genererte bilder må overholde leverandørens retningslinjer for bruk. Ikke send ulovlige, voldelige, pornografiske eller opphavsrettskrenkende Prompts.
## OpenAPI
````yaml api/openapi/image/openai/post-images.openapi.json POST /v1/images/generations
openapi: 3.1.0
info:
title: Images API
version: 1.0.0
description: >-
Create images through the OpenAI-compatible CometAPI image generation route.
Request parameters vary by model. For the latest model-specific controls,
refer to the OpenAI image generation guide:
https://developers.openai.com/api/docs/guides/image-generation
servers:
- url: https://api.cometapi.com
security:
- bearerAuth: []
paths:
/v1/images/generations:
post:
summary: Create images
description: >-
Generate images from a text prompt using OpenAI-compatible request
shapes on CometAPI. For the latest model-specific output controls and
parameter support, refer to the OpenAI image generation guide:
https://developers.openai.com/api/docs/guides/image-generation
operationId: images
requestBody:
required: true
content:
application/json:
schema:
type: object
required:
- model
- prompt
properties:
model:
type: string
description: >-
The image generation model to use. Choose a current model
from the [Models page](/overview/models).
default: gpt-image-2
prompt:
type: string
description: Text description of the image you want to generate.
example: A paper boat floating on calm water at sunrise.
'n':
type: integer
description: >-
Number of images to generate. Keep this at 1 for the
broadest compatibility.
default: 1
quality:
type: string
description: >-
Quality setting for models that support it. GPT image models
accept `low`, `medium`, `high`, and `auto`.
`gpt-image-2.5-sunburst` and `gpt-image-2.5-flare` also
accept `xhigh` and `max`. `dall-e-3` accepts `standard` and
`hd`. See the OpenAI image generation guide for the latest
model-specific values.
example: low
background:
type: string
description: >-
Background mode for the generated image. Set `transparent`
to generate an isolated subject with no background fill;
this requires `output_format` set to `png` or `webp`, and
returns an error with `jpeg`. Set `opaque` for a solid
background, or `auto` to let the model decide. Supported on
`gpt-image-2.5-sunburst` and `gpt-image-2.5-flare`.
enum:
- transparent
- opaque
- auto
output_compression:
type: integer
description: >-
Compression level for the output image, from 0 to 100.
Applies when `output_format` is `webp` or `jpeg`. Lower
values produce smaller files with more compression
artifacts.
minimum: 0
maximum: 100
default: 100
moderation:
type: string
description: >-
Content moderation level for GPT image models. `low` is less
restrictive; `auto` is the default.
enum:
- low
- auto
default: auto
partial_images:
type: integer
description: >-
Number of partial images to emit while a streaming response
is in progress, from 0 to 3. Each partial image arrives as
an `image_generation.partial_image` event before the final
`image_generation.completed` event. Applies when `stream` is
`true`.
minimum: 0
maximum: 3
size:
type: string
description: >-
Requested output size. Supported values depend on the
selected model. See the OpenAI image generation guide for
the latest model-specific ranges.
example: 1024x1024
response_format:
type: string
description: >-
The response container for `dall-e-2` and `dall-e-3`. This
parameter is not supported for GPT image models, which
return base64-encoded image data.
enum:
- url
- b64_json
output_format:
type: string
description: >-
The encoded image type for GPT image model results, such as
`png`, `jpeg`, or `webp`. See the OpenAI image generation
guide for current GPT image output controls.
example: jpeg
stream:
type: boolean
description: >-
Set this to `true` to receive server-sent image generation
events instead of waiting for the completed JSON response.
Streaming responses use `text/event-stream` and can include
final events such as `image_generation.completed`. When
`stream` and `async` are both `true`, async task mode takes
precedence and the create request returns JSON instead of a
streaming image response.
default: false
async:
type: boolean
description: >-
CometAPI asynchronous task mode. Set this to `true` to
return immediately with `data.task_id`, then poll `GET
/v1/images/generations/{task_id}` for the final image data.
Documented model IDs for this mode: `gpt-image-2` and
`doubao-seedream-4-0-250828`. This is a CometAPI extension,
not an OpenAI parameter. When `async` and `stream` are both
`true`, async takes precedence and returns JSON task
metadata instead of an SSE stream.
default: false
default:
model: gpt-image-2
prompt: A paper boat floating on calm water at sunrise.
'n': 1
size: 1024x1024
output_format: jpeg
examples:
gpt_image:
summary: GPT image generation (gpt-image-2)
value:
model: gpt-image-2
prompt: A paper boat floating on calm water at sunrise.
quality: low
size: 1024x1024
output_format: jpeg
transparent_background:
summary: Transparent background (gpt-image-2.5-sunburst)
value:
model: gpt-image-2.5-sunburst
prompt: A single red apple, centered, isolated subject.
quality: low
size: 1024x1024
background: transparent
output_format: png
streaming_image:
summary: Streaming image generation
value:
model: gpt-image-2
prompt: A paper boat floating on calm water at sunrise.
quality: low
size: 1024x1024
output_format: jpeg
stream: true
async_image:
summary: Async image generation
value:
model: gpt-image-2
prompt: A paper boat floating on calm water at sunrise.
quality: low
size: 1024x1024
output_format: jpeg
async: true
gpt_image_1:
summary: GPT image generation (gpt-image-1)
value:
model: gpt-image-1
prompt: A paper boat floating on calm water at sunrise.
quality: low
size: 1024x1024
responses:
'200':
description: >-
Image generation result. Synchronous requests return completed image
data. Async requests return a task response with `data.task_id`.
content:
application/json:
schema:
oneOf:
- type: object
title: Completed image response
required:
- created
- data
properties:
created:
type: integer
description: Unix timestamp for the completed generation.
background:
type: string
description: Background mode returned by models that expose it.
output_format:
type: string
description: Encoded image type returned by GPT image models.
quality:
type: string
description: Quality level returned by models that expose it.
size:
type: string
description: Output size returned by models that expose it.
usage:
type: object
description: >-
Token usage details when returned by the selected
model.
properties:
input_tokens:
type: integer
output_tokens:
type: integer
total_tokens:
type: integer
input_tokens_details:
type: object
properties:
image_tokens:
type: integer
text_tokens:
type: integer
output_tokens_details:
type: object
properties:
image_tokens:
type: integer
text_tokens:
type: integer
data:
type: array
items:
type: object
properties:
url:
type: string
description: >-
Temporary image URL when the selected model
supports URL output.
b64_json:
type: string
description: >-
Base64-encoded image payload for models that
return inline content.
revised_prompt:
type: string
description: Provider-rewritten prompt, when available.
- type: object
title: Async task response
required:
- code
- data
properties:
code:
type: string
description: >-
Request status code. A successful async submit returns
`success`.
example: success
message:
type: string
description: Optional status message.
data:
type: object
required:
- task_id
- status
- data
properties:
task_id:
type: string
description: >-
Task ID to pass to `GET
/v1/images/generations/{task_id}`.
status:
type: string
description: Task state for the submitted image generation job.
enum:
- pending
- success
- failure
data:
type: array
description: >-
Empty at submit time. Poll the task endpoint to
receive final image data.
items:
type: object
example:
code: success
message: ''
data:
task_id:
status: pending
data: []
example:
created: 1781075000
background: opaque
output_format: jpeg
quality: low
size: 1024x1024
usage:
input_tokens: 13
input_tokens_details:
image_tokens: 0
text_tokens: 13
output_tokens: 196
output_tokens_details:
image_tokens: 196
text_tokens: 0
total_tokens: 209
data:
- b64_json: /9j/4AAQSkZJRgABAQAAAQABAAD...
text/event-stream:
schema:
type: string
description: >-
Server-sent events returned when `stream` is `true`. Events
can include image generation progress and final image data.
example: >+
event: image_generation.completed
data:
{"created_at":1783305600,"type":"image_generation.completed","b64_json":""}
x-codeSamples:
- lang: Shell
label: Default
source: |
curl https://api.cometapi.com/v1/images/generations \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2",
"prompt": "A paper boat floating on calm water at sunrise.",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg"
}'
- lang: Python
label: Default
source: |
import base64
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.cometapi.com/v1",
api_key=os.environ["COMETAPI_KEY"],
)
result = client.images.generate(
model="gpt-image-2",
prompt="A paper boat floating on calm water at sunrise.",
quality="low",
size="1024x1024",
output_format="jpeg",
)
image_bytes = base64.b64decode(result.data[0].b64_json)
with open("boat.jpg", "wb") as f:
f.write(image_bytes)
- lang: JavaScript
label: Default
source: >
import fs from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.cometapi.com/v1",
apiKey: process.env.COMETAPI_KEY,
});
const result = await client.images.generate({
model: "gpt-image-2",
prompt: "A paper boat floating on calm water at sunrise.",
quality: "low",
size: "1024x1024",
output_format: "jpeg",
});
fs.writeFileSync("boat.jpg", Buffer.from(result.data[0].b64_json,
"base64"));
- lang: Shell
label: Transparent background
source: |-
curl https://api.cometapi.com/v1/images/generations \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2.5-sunburst",
"prompt": "A single red apple, centered, isolated subject.",
"quality": "low",
"size": "1024x1024",
"background": "transparent",
"output_format": "png"
}' | jq -r '.data[0].b64_json' | base64 --decode > apple.png
- lang: Python
label: Transparent background
source: |-
import base64
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.cometapi.com/v1",
api_key=os.environ["COMETAPI_KEY"],
)
result = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt="A single red apple, centered, isolated subject.",
quality="low",
size="1024x1024",
background="transparent",
output_format="png",
)
image_bytes = base64.b64decode(result.data[0].b64_json)
with open("apple.png", "wb") as f:
f.write(image_bytes)
- lang: JavaScript
label: Transparent background
source: >-
import fs from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.cometapi.com/v1",
apiKey: process.env.COMETAPI_KEY,
});
const result = await client.images.generate({
model: "gpt-image-2.5-sunburst",
prompt: "A single red apple, centered, isolated subject.",
quality: "low",
size: "1024x1024",
background: "transparent",
output_format: "png",
});
fs.writeFileSync("apple.png", Buffer.from(result.data[0].b64_json,
"base64"));
- lang: Shell
label: Streaming request
source: |
curl -N https://api.cometapi.com/v1/images/generations \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2",
"prompt": "A paper boat floating on calm water at sunrise.",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
"stream": true
}'
- lang: Python
label: Streaming request
source: |
import json
import os
import urllib.request
payload = {
"model": "gpt-image-2",
"prompt": "A paper boat floating on calm water at sunrise.",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
"stream": True,
}
request = urllib.request.Request(
"https://api.cometapi.com/v1/images/generations",
data=json.dumps(payload).encode("utf-8"),
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"],
"Content-Type": "application/json",
},
method="POST",
)
with urllib.request.urlopen(request) as response:
for raw_line in response:
line = raw_line.decode("utf-8").strip()
if line:
print(line)
- lang: JavaScript
label: Streaming request
source: >
const response = await
fetch("https://api.cometapi.com/v1/images/generations", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "gpt-image-2",
prompt: "A paper boat floating on calm water at sunrise.",
quality: "low",
size: "1024x1024",
output_format: "jpeg",
stream: true,
}),
});
const decoder = new TextDecoder();
for await (const chunk of response.body) {
process.stdout.write(decoder.decode(chunk));
}
- lang: Shell
label: Async request
source: |
curl https://api.cometapi.com/v1/images/generations \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2",
"prompt": "A paper boat floating on calm water at sunrise.",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
"async": true
}'
- lang: Python
label: Async request
source: |
import os
import requests
response = requests.post(
"https://api.cometapi.com/v1/images/generations",
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"],
"Content-Type": "application/json",
},
json={
"model": "gpt-image-2",
"prompt": "A paper boat floating on calm water at sunrise.",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
"async": True,
},
)
result = response.json()
print(result["data"]["task_id"])
- lang: JavaScript
label: Async request
source: >
const response = await
fetch("https://api.cometapi.com/v1/images/generations", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "gpt-image-2",
prompt: "A paper boat floating on calm water at sunrise.",
quality: "low",
size: "1024x1024",
output_format: "jpeg",
async: true,
}),
});
const result = await response.json();
console.log(result.data.task_id);
components:
securitySchemes:
bearerAuth:
type: http
scheme: bearer
description: Bearer token authentication. Use your CometAPI key.
````