Name: Imagen 4 Fast API: Google Text to Image Generator
Brand: magicapi
SKU: api-magicapi-fast-text-to-image-api-google-imagen-4-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 Text-to-Image Generator API (Google Imagen 4 Fast)

## Overview
Imagen 4 Fast is a text-to-image model from Google. Its developer recommends this fast version of Imagen 4 when speed and cost are more important than quality.

Send a text `prompt` and choose the `aspect_ratio`, `output_format` and `safety_filter_level`. Each request returns the URL of one image.

## Features
- **Text to image**: describe the scene in `prompt`, including any text you want written in the image.
- **Aspect ratios**: `1:1` (default), `9:16`, `16:9`, `3:4`, `4:3`.
- **Output formats**: `jpg` (default) or `png`.
- **Safety filter**: `safety_filter_level` is `block_only_high` (default, most permissive), `block_medium_and_above` or `block_low_and_above` (strictest). Some prompts are blocked at every level.

## Use Cases
1. **Marketing and social images**: posters and banners in the aspect ratio of each placement.
2. **Concept and mood images**: cinematic scenes, as in the example, for storyboards and pitches.
3. **High-volume generation**: drafts and variations where speed and cost matter more than maximum quality.
4. **Images with short text**: titles or slogans written into the scene.

## Visual Examples
### Example Input
Prompt: "The photo: Create a cinematic, photorealistic medium shot capturing the dynamic energy of a high-octane action film. The focus is a young woman with wind-swept dark hair streaked with pink highlights and determined features, looking directly and intently into the camera lens, she is slightly off-center. She wears a fitted pink and gold racing jacket over a black tank top with "Imagen 4 Fast" in motion-stylized lettering and on the next line "on api.market" emblazoned across the chest and aviator sunglasses pushed up on her head. The lighting is dramatic with motion blur streaks and neon reflections from passing city lights, creating dynamic lens flares and light trails (they do not cover her face). The background shows a blurred urban nightscape with streaking car headlights and illuminated skyscrapers rushing past, rendered with heavy motion blur and shallow depth of field. High contrast lighting, vibrant neon color palette with deep blues and electric yellows, and razor-sharp focus on her intense eyes enhance the fast-paced, electrifying atmosphere. She is illuminated while the background is darker."

Settings: `aspect_ratio` `4:3`, `output_format` `jpg`, `safety_filter_level` `block_only_high`.

### Example Output
![Imagen 4 Fast output: a cinematic shot of a young woman in a pink and gold racing jacket lettered Imagen 4 Fast on api.market, against a blurred neon city at night](https://blog.api.market/wp-content/uploads/2026/10/imagen-4-fast-output-9y8wmgxd-api-market.jpeg)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for image generation |
| `aspect_ratio` | string | No | `1:1` | `1:1`, `9:16`, `16:9`, `3:4`, `4:3` | Aspect ratio of the generated image |
| `safety_filter_level` | string | No | `block_only_high` | `block_low_and_above`, `block_medium_and_above`, `block_only_high` | `block_low_and_above` is strictest, `block_medium_and_above` blocks some prompts, `block_only_high` is most permissive but some prompts will still be blocked |
| `output_format` | string | No | `jpg` | `jpg`, `png` | Format of the output image |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.025 per API unit.
- **1 API unit = 1 output image.** Each request returns one image, so each successful request costs $0.025.
- Every aspect ratio, output format and safety level is billed the same.
- **Example cost**: the request below returned 1 image = **$0.025**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/fast-text-to-image-api-google-imagen-4-fast`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-text-to-image-api-google-imagen-4-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "google/imagen-4-fast",
    "input": {
      "prompt": "The photo: Create a cinematic, photorealistic medium shot capturing the dynamic energy of a high-octane action film. The focus is a young woman with wind-swept dark hair streaked with pink highlights and determined features, looking directly and intently into the camera lens, she is slightly off-center. She wears a fitted pink and gold racing jacket over a black tank top with \"Imagen 4 Fast\" in motion-stylized lettering and on the next line \"on api.market\" emblazoned across the chest and aviator sunglasses pushed up on her head. The lighting is dramatic with motion blur streaks and neon reflections from passing city lights, creating dynamic lens flares and light trails (they do not cover her face). The background shows a blurred urban nightscape with streaking car headlights and illuminated skyscrapers rushing past, rendered with heavy motion blur and shallow depth of field. High contrast lighting, vibrant neon color palette with deep blues and electric yellows, and razor-sharp focus on her intense eyes enhance the fast-paced, electrifying atmosphere. She is illuminated while the background is darker.",
      "aspect_ratio": "4:3",
      "output_format": "jpg",
      "safety_filter_level": "block_only_high"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "9y8wmgxd65rmy0d1c71tss0y14",
  "version": "google/imagen-4-fast",
  "status": "starting",
  "created_at": "2026-10-22T03:59:36.408Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-text-to-image-api-google-imagen-4-fast/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "9y8wmgxd65rmy0d1c71tss0y14",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/imagen-4-fast-output-9y8wmgxd-api-market.jpeg",
  "error": null,
  "created_at": "2026-10-22T03:59:36.408Z",
  "started_at": "2026-10-22T03:59:36.908Z",
  "completed_at": "2026-10-22T03:59:44.401Z"
}
```

`output` is a single URL string pointing to the generated image.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or an `aspect_ratio` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.
## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-text-to-image-api-google-imagen-4-fast";

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

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

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

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

    const prediction = await response.json();

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

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

    await delay(pollInterval);
  }

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

createAndWaitForPrediction({
  "prompt": "The photo: Create a cinematic, photorealistic medium shot capturing the dynamic energy of a high-octane action film. The focus is a young woman with wind-swept dark hair streaked with pink highlights and determined features, looking directly and intently into the camera lens, she is slightly off-center. She wears a fitted pink and gold racing jacket over a black tank top with \"Imagen 4 Fast\" in motion-stylized lettering and on the next line \"on api.market\" emblazoned across the chest and aviator sunglasses pushed up on her head. The lighting is dramatic with motion blur streaks and neon reflections from passing city lights, creating dynamic lens flares and light trails (they do not cover her face). The background shows a blurred urban nightscape with streaking car headlights and illuminated skyscrapers rushing past, rendered with heavy motion blur and shallow depth of field. High contrast lighting, vibrant neon color palette with deep blues and electric yellows, and razor-sharp focus on her intense eyes enhance the fast-paced, electrifying atmosphere. She is illuminated while the background is darker.",
  "aspect_ratio": "4:3",
  "output_format": "jpg",
  "safety_filter_level": "block_only_high"
}).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-text-to-image-api-google-imagen-4-fast"

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": "google/imagen-4-fast", "input": input_data},
    )

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

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    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"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

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

output = create_and_wait_for_prediction({
    "prompt": "The photo: Create a cinematic, photorealistic medium shot capturing the dynamic energy of a high-octane action film. The focus is a young woman with wind-swept dark hair streaked with pink highlights and determined features, looking directly and intently into the camera lens, she is slightly off-center. She wears a fitted pink and gold racing jacket over a black tank top with \"Imagen 4 Fast\" in motion-stylized lettering and on the next line \"on api.market\" emblazoned across the chest and aviator sunglasses pushed up on her head. The lighting is dramatic with motion blur streaks and neon reflections from passing city lights, creating dynamic lens flares and light trails (they do not cover her face). The background shows a blurred urban nightscape with streaking car headlights and illuminated skyscrapers rushing past, rendered with heavy motion blur and shallow depth of field. High contrast lighting, vibrant neon color palette with deep blues and electric yellows, and razor-sharp focus on her intense eyes enhance the fast-paced, electrifying atmosphere. She is illuminated while the background is darker.",
    "aspect_ratio": "4:3",
    "output_format": "jpg",
    "safety_filter_level": "block_only_high"
})
print(output)
```

## FAQ
- **How many images does one request return?**
  - One. Each image is billed as one API unit ($0.025).
- **Why was my prompt blocked?**
  - The safety filter rejected it. `block_only_high` (the default) is the most permissive level, but some prompts are blocked at every level. Rephrase the prompt and try again.
- **Which aspect ratios are supported?**
  - `1:1`, `9:16`, `16:9`, `3:4` and `4:3`.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## 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.


Imagen 4 Fast API: generate images from text prompts with Google's faster, lower cost Imagen 4 model, in five aspect ratios as JPG or PNG. Pay per image.