openai/gpt-image-1/edit

Bild-zu-Bild

Openai GPT Image 1 Edit API by OpenAI

openai/gpt-image-1/edit

Edit

OpenAI's gpt-image-1 enables image generation and image editing via OpenAI's image API, ideal for creating and refining images. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Eingabe

Prompt *

Bild *

Sie können Dateien hier ablegen oder zum Hochladen klicken

MAX:1

Maskenbild

Sie können Dateien hier ablegen oder zum Hochladen klicken

MAX:1

Quality

Größe

Ausgabe

Inaktiv

Ihre generierten Bilder erscheinen hier

Konfigurieren Sie Parameter und klicken Sie auf Ausführen, um mit der Generierung zu beginnen

Jede Ausführung kostet $0.009. Für $10 können Sie ca. 1111 Mal ausführen.

Sie können fortfahren mit:

Bild zu Video Bild zu Bild

Parameter

Codebeispiel
import requests
import time

# Step 1: Start image generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "openai/gpt-image-1/edit",  # Required. model name
    "enable_base64_output": False,  # If enabled, the output will be encoded into a BASE64 string instead of a URL
    "enable_sync_mode": False,  # If set to true, the function will wait for the result to be generated and uploaded before returning the response
    "image": [],  # Required. The image to edit
    "mask_image": "example_value",  # An additional image whose fully transparent areas (e
    "prompt": "A beautiful landscape with mountains and lake",  # Required. The positive prompt for the generation
    "quality": "medium",  # The quality of the generated image. options: high | medium | low
    "size": "1024x1024",  # The size of the generated media in pixels (width*height). options: 1024x1024 | 1024x1536 | 1536x1024
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] == "completed":
            print("Generated image:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

image_url = check_status()

Installieren

Installieren Sie das erforderliche Paket für Ihre Programmiersprache.

pip install requests

Authentifizierung

Alle API-Anfragen erfordern eine Authentifizierung über einen API-Schlüssel. Sie können Ihren API-Schlüssel über das Atlas Cloud Dashboard erhalten.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP-Header

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Schützen Sie Ihren API-Schlüssel

Geben Sie Ihren API-Schlüssel niemals in clientseitigem Code oder öffentlichen Repositories preis. Verwenden Sie stattdessen Umgebungsvariablen oder einen Backend-Proxy.

Anfrage senden

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Anfrage senden

Senden Sie eine asynchrone Generierungsanfrage. Die API gibt eine Vorhersage-ID zurück, mit der Sie den Status prüfen und das Ergebnis abrufen können.

POST/api/v1/model/generateImage

Anfragekörper

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "openai/gpt-image-1/edit",
    "prompt": "A beautiful landscape with mountains and lake"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

Antwort

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

Status prüfen

Fragen Sie den Vorhersage-Endpunkt ab, um den aktuellen Status Ihrer Anfrage zu überprüfen.

GET/api/v1/model/prediction/{prediction_id}

Abfrage-Beispiel

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Statuswerte

processingDie Anfrage wird noch verarbeitet.

completedDie Generierung ist abgeschlossen. Ergebnisse sind verfügbar.

succeededDie Generierung war erfolgreich. Ergebnisse sind verfügbar.

failedDie Generierung ist fehlgeschlagen. Überprüfen Sie das Fehlerfeld.

Abgeschlossene Antwort

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.png"
    ],
    "metrics": {
      "predict_time": 8.3
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Dateien hochladen

Laden Sie Dateien in den Atlas Cloud Speicher hoch und erhalten Sie eine URL, die Sie in Ihren API-Anfragen verwenden können. Verwenden Sie multipart/form-data zum Hochladen.

POST/api/v1/model/uploadMedia

Upload-Beispiel

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

Antwort

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

Eingabe-Schema

Die folgenden Parameter werden im Anfragekörper akzeptiert.

Gesamt: 8Erforderlich: 3Optional: 5

modelstringrequired

model name

Default: "openai/gpt-image-1/edit"

enable_base64_outputboolean

If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.

Default: false

enable_sync_modeboolean

If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.

Default: false

imagearray[string]required

The image to edit.

Min items: 1Max items: 4

mask_imagestring

An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where image should be edited. If there are multiple images provided, the mask will be applied on the first image. Must be a valid PNG file

promptstringrequired

The positive prompt for the generation.

qualitystring

The quality of the generated image.

Default: "medium"

highmediumlow

sizestring

The size of the generated media in pixels (width*height).

Default: "1024x1024"

1024x10241024x15361536x1024

Beispiel-Anfragekörper

{
  "model": "openai/gpt-image-1/edit",
  "enable_base64_output": false,
  "enable_sync_mode": false,
  "image": [
    "https://example.com/file.jpg"
  ],
  "prompt": "A beautiful landscape",
  "quality": "medium",
  "size": "1024x1024"
}

Ausgabe-Schema

Die API gibt eine Vorhersage-Antwort mit den generierten Ausgabe-URLs zurück.

created_atstring

ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

idstring

Unique identifier for the prediction, the ID of the prediction to get.

modelstring

Model ID used for the prediction.

outputsarray

Array of URLs to the generated content (empty when status is not completed).

statusstring

Status of the task: created, processing, completed, or failed.

Beispielantwort

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.png"
  ],
  "metrics": {
    "predict_time": 8.3
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integriert über 300 KI-Modelle direkt in Ihren KI-Programmierassistenten. Ein Befehl zur Installation, dann generieren Sie per natürlicher Sprache Bilder und Videos und chatten mit LLMs.

Unterstützte Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ unterstützte clients

Installieren

npx skills add AtlasCloudAI/atlas-cloud-skills

API-Schlüssel einrichten

Erhalten Sie Ihren API-Schlüssel über das Atlas Cloud Dashboard und setzen Sie ihn als Umgebungsvariable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Funktionen

Nach der Installation können Sie natürliche Sprache in Ihrem KI-Assistenten verwenden, um auf alle Atlas Cloud Modelle zuzugreifen.

BildgenerierungGenerieren Sie Bilder mit Modellen wie Nano Banana 2, Z-Image und mehr.

VideoerstellungErstellen Sie Videos aus Text oder Bildern mit Kling, Vidu, Veo usw.

LLM-ChatChatten Sie mit Qwen, DeepSeek und anderen großen Sprachmodellen.

Medien-UploadLaden Sie lokale Dateien für Bildbearbeitung und Bild-zu-Video-Workflows hoch.

Mehr erfahren

github.com/AtlasCloudAI/atlas-cloud-skills

MCP-Server

Der Atlas Cloud MCP-Server verbindet Ihre IDE mit über 300 KI-Modellen über das Model Context Protocol. Funktioniert mit jedem MCP-kompatiblen Client.

Unterstützte Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ unterstützte clients

Installieren

npx -y atlascloud-mcp

Konfiguration

Fügen Sie die folgende Konfiguration zur MCP-Einstellungsdatei Ihrer IDE hinzu.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Verfügbare Werkzeuge

atlas_generate_imageGenerieren Sie Bilder aus Textbeschreibungen.

atlas_generate_videoErstellen Sie Videos aus Text oder Bildern.

atlas_chatChatten Sie mit großen Sprachmodellen.

atlas_list_modelsDurchsuchen Sie über 300 verfügbare KI-Modelle.

atlas_quick_generateInhaltserstellung in einem Schritt mit automatischer Modellauswahl.

atlas_upload_mediaLaden Sie lokale Dateien für API-Workflows hoch.

Mehr erfahren

github.com/AtlasCloudAI/mcp-server

API-Schema

{
  "info": {
    "description": "The AtlasCloud API.",
    "title": "AtlasCloud API",
    "version": "1.0.0"
  },
  "paths": {
    "/api/v1/model/generateImage": {
      "post": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/result/{request_id}": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        },
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "schema": {
              "type": "string",
              "description": "Request ID"
            },
            "required": true
          }
        ]
      },
      "x-api-name": "model_result"
    }
  },
  "openapi": "3.0.0",
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ],
  "components": {
    "schemas": {
      "Input": {
        "type": "object",
        "required": [
          "model",
          "image",
          "prompt"
        ],
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "openai/gpt-image-1/edit"
          },
          "enable_base64_output": {
            "default": false,
            "description": "If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.",
            "disabled": true,
            "type": "boolean"
          },
          "enable_sync_mode": {
            "default": false,
            "description": "If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.",
            "disabled": true,
            "type": "boolean"
          },
          "image": {
            "description": "The image to edit.",
            "items": {
              "type": "string"
            },
            "maxItems": 4,
            "minItems": 1,
            "type": "array"
          },
          "mask_image": {
            "description": "An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where image should be edited. If there are multiple images provided, the mask will be applied on the first image. Must be a valid PNG file",
            "type": "string"
          },
          "prompt": {
            "description": "The positive prompt for the generation.",
            "minLength": 1,
            "type": "string"
          },
          "quality": {
            "default": "medium",
            "description": "The quality of the generated image.",
            "enum": [
              "high",
              "medium",
              "low"
            ],
            "type": "string"
          },
          "size": {
            "default": "1024x1024",
            "description": "The size of the generated media in pixels (width*height).",
            "enum": [
              "1024x1024",
              "1024x1536",
              "1536x1024"
            ],
            "type": "string"
          }
        },
        "x-order-properties": [
          "prompt",
          "image",
          "mask_image",
          "quality",
          "size",
          "enable_sync_mode",
          "enable_base64_output"
        ]
      },
      "PredictionResponse": {
        "type": "object",
        "properties": {
          "created_at": {
            "description": "ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).",
            "format": "date-time",
            "type": "string"
          },
          "has_nsfw_contents": {
            "description": "Array of boolean values indicating NSFW detection for each output.",
            "items": {
              "type": "boolean"
            },
            "type": "array"
          },
          "id": {
            "description": "Unique identifier for the prediction, the ID of the prediction to get.",
            "type": "string"
          },
          "model": {
            "description": "Model ID used for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array of URLs to the generated content (empty when status is not completed).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "status": {
            "description": "Status of the task: created, processing, completed, or failed.",
            "type": "string"
          },
          "urls": {
            "description": "Object containing related API endpoints.",
            "type": "object"
          }
        }
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  }
}

LLM-freundliche Prompt-Vorlage

# openai/gpt-image-1/edit

> OpenAI's gpt-image-1 enables image generation and image editing via OpenAI's image API, ideal for creating and refining images. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateImage` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `openai/gpt-image-1/edit`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`prompt`** (`string`, _required_):
  The positive prompt for the generation.

- **`image`** (`array[string]`, _required_):
  The image to edit.
  - Min items: 1
  - Max items: 4

- **`mask_image`** (`string`, _optional_):
  An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where image should be edited. If there are multiple images provided, the mask will be applied on the first image. Must be a valid PNG file

- **`quality`** (`string`, _optional_):
  The quality of the generated image.
  - Default: `"medium"`
  - Options: "high", "medium", "low"

- **`size`** (`string`, _optional_):
  The size of the generated media in pixels (width*height).
  - Default: `"1024x1024"`
  - Options: "1024x1024", "1024x1536", "1536x1024"

- **`enable_sync_mode`** (`boolean`, _optional_):
  If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.
  - Default: `false`

- **`enable_base64_output`** (`boolean`, _optional_):
  If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.
  - Default: `false`



**Required Parameters Example**:

```json
{
  "model": "openai/gpt-image-1/edit",
  "image": [
    ""
  ],
  "prompt": ""
}
```


**Full Example**:

```json
{
  "model": "openai/gpt-image-1/edit",
  "prompt": "",
  "image": [
    ""
  ],
  "mask_image": "",
  "quality": "medium",
  "size": "1024x1024",
  "enable_sync_mode": false,
  "enable_base64_output": false
}
```


### Output Schema

The API returns the following output format:


- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

- **`has_nsfw_contents`** (`array[boolean]`, _optional_):
  Array of boolean values indicating NSFW detection for each output.

- **`id`** (`string`, _optional_):
  Unique identifier for the prediction, the ID of the prediction to get.

- **`model`** (`string`, _optional_):
  Model ID used for the prediction.

- **`outputs`** (`array[string]`, _optional_):
  Array of URLs to the generated content (empty when status is not completed).

- **`status`** (`string`, _optional_):
  Status of the task: created, processing, completed, or failed.

- **`urls`** (`object`, _optional_):
  Object containing related API endpoints.



**Example Response**:

```json
{
  "created_at": "",
  "has_nsfw_contents": [],
  "id": "",
  "model": "",
  "outputs": [
    ""
  ],
  "status": "",
  "urls": {}
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "openai/gpt-image-1/edit",
  "prompt": "",
  "image": [
    ""
  ],
  "mask_image": "",
  "quality": "medium",
  "size": "1024x1024",
  "enable_sync_mode": false,
  "enable_base64_output": false
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/openai/gpt-image-1/edit)

Keine Beispiele verfügbar

Wird geladen...

OpenAI GPT-Image-1-Edit

Edit and transform images with natural language using OpenAI's GPT-Image-1-Edit. This versatile model understands your instructions to apply style changes, modifications, and creative transformations — with optional mask support for precise regional editing and multiple quality tiers to match your needs and budget.

Why It Looks Great

Natural language editing: Describe transformations in plain text — style changes, modifications, enhancements.
Mask support: Use mask images for precise control over which areas to edit.
Quality tiers: Choose from low, medium, or high quality based on your needs.
Multiple sizes: Output in square (1024x1024) or rectangular (1024x1536, 1536x1024) formats.
Style transformation: Excels at converting images to different artistic styles.
OpenAI quality: Powered by advanced vision-language understanding.

Parameters

Parameter	Required	Description
`prompt`	Yes	Text instruction describing the edit or transformation you want.
`image`	Yes	Source image to edit (upload or public URL).
`quality`	No	Output quality: `low`, `medium`, or `high`. Default: `medium`.
`mask_image`	No	Optional mask to specify edit regions (upload or URL).
`size`	No	Output dimensions: `1024x1024`, `1024x1536`, or `1536x1024`.
`enable_sync_mode`	No	API only: Waits for result and returns it directly.
`enable_base64_output`	No	API only: Returns base64 string instead of URL.

How to Use

Write your edit instruction — describe the transformation you want (e.g. "Become a comic style").
Upload your image — drag and drop or paste a public URL.
Choose quality — select low, medium, or high based on your needs.
Add mask (optional) — upload a mask image to limit edits to specific areas.
Select size — choose your desired output dimensions.
Run — click the button to apply the edit.
Download — preview and save your transformed image.

Quick Reference

Quality	1024x1024	1024x1536 / 1536x1024
Low	$0.011	$0.016
Medium	$0.042	$0.063
High	$0.167	$0.250

Best Use Cases

Style Transfer — Convert photos to comic, cartoon, painting, or other artistic styles.
Creative Transformation — Reimagine images with different aesthetics or themes.
Regional Editing — Use masks to edit specific areas while preserving the rest.
Content Enhancement — Improve or modify specific aspects of images.
Artistic Interpretation — Transform photos into various art forms.

Example Prompts

"Become a comic style"
"Transform into a watercolor painting"
"Make it look like a vintage photograph from the 1950s"
"Convert to anime style illustration"
"Apply a cyberpunk neon aesthetic"
"Turn into a pencil sketch"

Quality Guide

Quality	Best For	Trade-off
Low	Quick previews, testing concepts, high-volume processing	Fastest, most affordable, lower detail
Medium	General use, social media, balanced needs	Good quality/cost balance
High	Professional work, final deliverables, maximum detail	Highest quality, premium price

Pro Tips for Best Results

Start with medium quality to test your prompt, then upgrade to high for final output.
Use masks when you want to preserve specific areas untouched.
Be specific about the target style — "comic style", "oil painting", "anime".
For style transfers, simpler source images often produce cleaner results.
Rectangular sizes work well for portraits (1024x1536) or landscapes (1536x1024).
The model interprets style instructions creatively — embrace the artistic interpretation.

Notes

If using URLs for images or masks, ensure they are publicly accessible.
The enable_sync_mode and enable_base64_output options are only available through the API.
Mask images should be black and white, where white indicates areas to edit.
Processing time varies by quality level — higher quality takes longer.

Openai GPT Image 2 Text-to-Image

GPT Image 2 text to image is OpenAI's fast, cost-efficient text-to-image generator powered by GPT-5 guidance. Create photorealistic shots, product renders, concept art, and stylized graphics from natural-language prompts (optionally conditioned with an image). Supports custom aspect ratios, seeds, negative prompts, hex color hints, and style presets. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

GPT Image 1 Mini is a cost-efficient, natively multimodal OpenAI model that pairs GPT-5 language understanding with compact image editing and generation from text and image inputs to produce high-quality images. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

GPT Image 2 Developer Edit

GPT Image 2 Developer Edit applies natural-language instructions to one or more reference images, with common aspect ratios and 1k, 2k, or supported 4k output tiers. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

GPT Image 2 Developer Text-to-Image

GPT Image 2 Developer Text-to-Image generates polished visuals from natural-language prompts, with common aspect ratios and 1k, 2k, or supported 4k output tiers. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

MAI-Image-2.5-Flash Text-to-image

Microsoft's fast, cost-optimized text-to-image generation model, creating high-quality images at lower cost using the same diffusion-based architecture as MAI-Image-2.5.

From

$0.03/BILD