Name: High-Quality Text-to-Image API (GPT-Image-2)
Brand: magicapi
SKU: api-magicapi-text-to-image-api-high-quality-openai-gpt-image-2
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ High-Quality Text-to-Image Generator API (GPT-Image-2)

## Overview
OpenAI's GPT-Image-2 API enables you to create and edit high-quality images from textual descriptions. Leveraging state-of-the-art image generation technology, this API excels at following instructions, rendering sharp text, and allowing detailed edits.



## Features
- **Text-to-Image Generation:** Convert textual descriptions into high-quality images.
- **Image Editing:** Modify existing images using detailed textual instructions.
- **Style Transfer:** Apply stylistic changes to images based on textual cues.
- **Sharp Text Rendering:** Generate images with clear and sharp text elements.
- **Detailed Instruction Following:** Adhere closely to complex and detailed instructions in image generation.

## Use Cases
1. **Marketing and Advertising:** Create customized promotional images based on product descriptions or campaign themes.
2. **Content Creation:** Generate high-quality graphics for blogs, articles, and social media posts.
3. **E-commerce:** Produce elaborate product images and visual content for online stores.
4. **Art and Design:** Utilize AI to craft unique visual elements and artwork.
5. **Entertainment:** Develop eye-catching visuals for media, music albums, or game covers.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "A photo of a computer screen displaying a music playlist in golden hour evening in a living room with lots of green plants in the background. The playlist is called GPT-image-2 and the caption says \"this new image model from OpenAI is dope.\" The artist and the account name are api.market. Use the provided api.market logo as the profile picture and artist image.",
    "input_images": [
      "https://api.market/img/brand/apimarket-logo.webp"
    ],
    "aspect_ratio": "3:2",
    "output_format": "webp",
    "number_of_images": 1
  }
}
```

![Reference image: the api.market logo](https://api.market/img/brand/apimarket-logo.webp)

### Example Output

![Example output from High-Quality Text-to-Image Generator API (GPT-Image-2)](https://blog.api.market/wp-content/uploads/2026/09/gpt-image-2-output-api-market.webp)

This exact request was run through api.market and billed 11 API units ($0.165).
## Pricing
- Pay As You Go (PAYG) pricing - you only pay for what you use.
- **Price:** $0.015 per API unit.
- **1 API unit** = **1 output image**; a request that returns several images is billed for each one.
- The base rate applies to `quality: "low"`: one image bills 1 unit ($0.015).
- `quality: "medium"` counts as **3.917 units** per image, rounded up to whole units per request (one image bills 4 units, $0.06).
- `quality: "auto"` counts as **10.667 units** per image, rounded up to whole units per request (one image bills 11 units, $0.165).
- `quality: "high"` counts as **10.667 units** per image, rounded up to whole units per request (one image bills 11 units, $0.165).
- A request that does not set `quality` uses the default, `"auto"`, and counts as **10.667 units** per image (one image bills 11 units, $0.165).
- Failed or cancelled predictions are not billed.
- GET requests to check prediction status (`GET /api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2/predictions/{id}`) are free and don't count toward API unit usage.
- No monthly subscription fee.

## API Documentation

### Base URL
All API requests should be made to:
```
https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2
```

### Authentication
Authentication is handled via an API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:
1. Submit a prediction request to the POST endpoint.
2. Receive a prediction ID in the response.
3. Poll the GET endpoint with the prediction ID to check status.
4. Continue polling until the prediction is complete.

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

### Input Parameters
| Name | Type | Required | Default | Allowed values and notes |
|---|---|---|---|---|
| `prompt` | string | Yes | none | Text description of the desired image |
| `aspect_ratio` | string | No | `"1:1"` | `1:1`, `3:2`, `2:3`, `4:3`, `3:4`, `16:9`, `9:16`, `auto`, or an exact size: `1024x1024`, `1536x1024`, `1024x1536`, `1536x1152`, `1152x1536`, `2048x2048`, `2048x1152`, `1152x2048`, `3840x2160`, `2160x3840`. Sizes above 2560x1440 are experimental |
| `input_images` | array of URIs | No | none | Images to edit or use as references |
| `number_of_images` | integer | No | `1` | 1 to 10; each image is billed |
| `quality` | string | No | `"auto"` | `low`, `medium`, `high`, `auto`; sets the price per image (see Pricing) |
| `background` | string | No | `"auto"` | `auto`, `transparent`, `opaque` |
| `output_compression` | integer | No | `90` | 0 to 100 |
| `output_format` | string | No | `"webp"` | `png`, `jpeg`, `webp` |
| `moderation` | string | No | `"auto"` | `auto`, `low` |
| `user_id` | string | No | none | Optional end-user identifier that helps OpenAI detect abuse |

### Endpoints
#### Create a Prediction
Create a new image prediction based on input parameters.

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "225c978a7f938acc350564c4548ddc2476bfb33364bec6b5422227f55ce56bd3",
    "input": {
      "prompt": "A photo of a computer screen displaying a music playlist in golden hour evening in a living room...",
      "quality": "auto",
      "background": "auto",
      "moderation": "auto",
      "aspect_ratio": "3:2",
      "input_images": ["https://api.market/img/brand/apimarket-logo.webp"],
      "output_format": "webp",
      "number_of_images": 1,
      "output_compression": 90
    }
  }'
```

#### Check Prediction Status
Poll the prediction status to check if results are ready.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Status Codes
- **200 OK:** Request successful.
- **201 Created:** Resource successfully created.
- **400 Bad Request:** Invalid input parameters or malformed request.
- **401 Unauthorized:** Missing or invalid API key.
- **403 Forbidden:** Valid API key but insufficient permissions.
- **404 Not Found:** Resource not found.
- **429 Too Many Requests:** Rate limit exceeded.
- **500 Internal Server Error:** Server-side error.
- **503 Service Unavailable:** Service temporarily unavailable.

### Rate Limits
- **Rate limits:** Requests over the plan's rate limit return 429 Too Many Requests; retry with exponential backoff. The pay-as-you-go plan has no monthly quota.

### Error Handling
Check the HTTP status code and error message. Fix 400 errors by correcting the input, and retry 429 and 5xx errors with exponential backoff.

#### Common Errors
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code
#### JavaScript Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "225c978a7f938acc350564c4548ddc2476bfb33364bec6b5422227f55ce56bd3", input: inputData })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();
    const predictionId = prediction.id;

    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second between checks

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}
```

#### Python Example
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }

    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "225c978a7f938acc350564c4548ddc2476bfb33364bec6b5422227f55ce56bd3", "input": input_data}
    )

    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second between checks

    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")
```

#### cURL Example
```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "225c978a7f938acc350564c4548ddc2476bfb33364bec6b5422227f55ce56bd3",
    "input": {
      "prompt": "A photo of a computer screen displaying a music playlist in golden hour evening in a living room...",
      "quality": "auto",
      "background": "auto",
      "moderation": "auto",
      "aspect_ratio": "3:2",
      "input_images": ["https://api.market/img/brand/apimarket-logo.webp"],
      "output_format": "webp",
      "number_of_images": 1,
      "output_compression": 90
    }
  }'

# Response contains prediction ID like: {"id": "abcd1234", "status": "starting"}

# Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-api-high-quality-openai-gpt-image-2/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: Repeatedly poll this endpoint manually until status is "succeeded"
```

### Performance Optimization
- Use appropriate image quality settings to balance cost and performance.
- Implement polling intervals to avoid API rate limits.
- Utilize asynchronous handling to improve user experience.

## FAQ
1. **How do I authenticate with the API?**
   Use your API key in the request header:
   ```
   x-api-market-key: YOUR_API_MARKET_KEY
   ```

2. **How long does it take to generate an image?**
   The processing time varies based on the complexity of the request. Typical wait times range from a few seconds to several minutes.

3. **What if my prediction request fails?**
   Failed predictions are not billed. Implement error handling to retry or log the issue.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.

Generate detailed, high-quality images from text instructions using OpenAI's GPT-Image-2. Ideal for precise and creative visual content.