> ## Documentation Index
> Fetch the complete documentation index at: https://docs.scitix.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Image Generation

Image Generation models create images from text prompts and can also edit images based on a reference image. They are suitable for creative design, marketing assets, concept art, product visual exploration, and synthetic dataset creation.

Image Generation is different from vision and multimodal understanding. Vision models primarily understand input images and generate text responses. Image Generation models primarily generate images from input conditions. The two types of capabilities usually use different models, input formats, output formats, parameters, and billing rules.

Representative model: `gpt-image-2`

For the complete model list and pricing, see the [Models](https://console.scitix.ai/model-inference/models) page.

## Core Capabilities

* **Text-to-image**: Generate illustrations, posters, concept images, or visual drafts from natural language prompts.
* **Image editing**: Modify an existing image based on text instructions, such as replacing the background, adjusting the style, or generating a new visual version.
* **Multiple image candidates**: Generate multiple candidate images in one request for later selection and iteration.
* **Visual concept exploration**: Quickly try different styles, compositions, color palettes, or scenes around the same theme.

<Tip>
  Supported input types, image sizes, output formats, style-control options, and generation speed may vary by image generation model. Before use, check the model details to confirm whether the target model supports the text-to-image, image editing, or multi-image generation capability you need.
</Tip>

## Use Cases

* **Marketing asset generation**: Generate candidate images for landing pages, social media, ads, or content operations.
* **Product visual exploration**: Quickly create product concept images with different styles, compositions, colors, or scenes.
* **Creative iteration**: Generate multiple candidates around the same theme, then manually select and refine them.
* **Dataset creation**: Generate synthetic images for demos, testing, or assisted annotation workflows.

## Key Parameters

Image generation requests usually include the following information:

* `prompt`: Describes the subject, scene, style, composition, colors, and constraints for the image. A more specific prompt helps the model understand the subject, scene, style, and constraints.
* `image`: The reference image used for image editing. This is required when using `client.images.edit()`.
* `size`: Controls image size. The basic example uses `1024x1024`; landscape images can use `1792x1024`. Image width and height must be divisible by 16. Use the model details and actual API responses as the source of truth for supported size ranges.
* `n`: Controls the number of images generated in one request. `n=1` and `n=2` can be used for basic generation. Generating multiple images usually increases cost and processing time.
* `quality`: Controls image quality. Current supported values are `low`, `medium`, `high`, and `auto`.

## Billing

The response returns `usage`, which can be used to inspect token usage for the request. Image generation usage fields differ from text generation and may include:

* `input_tokens`
* `input_tokens_details.text_tokens`
* `input_tokens_details.image_tokens`
* `output_tokens`
* `total_tokens`

Use the model details and usage page as the source of truth for billing.

## Usage Recommendations

* **Describe the subject and purpose clearly**: Explain what should be generated and whether the image is for a poster, product image, illustration, avatar, or concept design.
* **Add key visual details**: Describe the scene, composition, colors, materials, lighting, and style. Avoid contradictory requirements.
* **Iterate in a small scope first**: Generate a small number of images to validate the prompt and style, then adjust size, count, quality, or reference image.
* **Save prompts and parameters**: Record the model, prompt, size, quality, and other parameters for reproduction, comparison, and troubleshooting.
* **Review before publishing**: Before production use, check image quality, copyright risk, brand consistency, and content safety.

## Limitations

* Supported models, input formats, image sizes, generation count, response format, image storage method, and billing may vary by image generation model.
* Image generation is stochastic. The same prompt may not generate the exact same image every time.
* Images containing text, fine details, hands, logos, tables, or precise spatial relationships may require manual review and further editing.
* Higher resolution, more generated images, reference image editing, or higher quality modes usually increase processing time and cost.
* Do not include sensitive personal information, copyrighted content you do not have the right to use, or content that violates platform policies in prompts or reference images.

## Examples

The examples read the API Key from an environment variable so the key is not written into code.

```bash theme={null}
export API_KEY="YOUR_API_KEY"
```

### Generate an Image

The following example uses the OpenAI Python SDK to call `gpt-image-2`, generate one image, and save the returned Base64 image as a local PNG file.

For `gpt-image-2`, image results are in the response `data` array. Each image item includes a `b64_json` field, which can be decoded and saved as an image file.

<Note>
  The current `gpt-image-2` response returns Base64 image data. Do not rely on the `url` field to retrieve the image; even if the response structure includes `url`, it may be empty.
</Note>

```python theme={null}
import base64
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["API_KEY"],
    base_url="https://api.scitix.ai/model-api",
)

image = client.images.generate(
    model="gpt-image-2",
    prompt="A cute baby sea otter",
    size="1024x1024",
    n=1,
)

image_base64 = image.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

with open("sea-otter.png", "wb") as f:
    f.write(image_bytes)

print("Saved image to sea-otter.png")
```

### Edit an Image

`gpt-image-2` supports passing a reference image through `client.images.edit()` and generating an edited image based on the prompt.

```python theme={null}
import base64
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["API_KEY"],
    base_url="https://api.scitix.ai/model-api",
)

with open("input.png", "rb") as input_image:
    image = client.images.edit(
        model="gpt-image-2",
        image=input_image,
        prompt="Turn the image into a simple blue square icon.",
        size="1024x1024",
        n=1,
    )

image_base64 = image.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

with open("edited-image.png", "wb") as f:
    f.write(image_bytes)

print("Saved image to edited-image.png")
```