Name: Imagen-4 – Photorealistic Image Generation | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-photorealistic-text-to-image-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

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

## Overview
The Photorealistic Text-to-Image Generator API (Imagen-4) allows you to create high-fidelity, lifelike images from text prompts. This API uses Google’s Imagen-4 model, which is in preview and subject to change. With a simple REST interface, you can rapidly generate vivid, cinematic-quality images, tailored to match your creative vision.

## Features
- Quickly generate highly detailed, realistic images from textual descriptions  
- Support for custom aspect ratios  
- Multiple safety filter levels to control output appropriateness  
- Asynchronous generation for efficient and scalable workflows  

## Use Cases
1. Marketing & Advertising: Instantly create product mockups or campaign visuals without costly photo shoots.  
2. Media & Entertainment: Generate stills, concept art, or storyboards for upcoming films or games.  
3. E-Commerce: Rapidly prototype lifestyle images showcasing your merchandise in unique settings.  
4. Art & Graphic Design: Jumpstart your creative projects with photorealistic references or concept drafts.  
5. Education & Training: Produce visual aids and illustrations based on custom text prompts for interactive learning materials.  

## Visual Examples

### Example Prompt & Output
Below is an example text prompt and a generated image output demonstrating the photo-realism capabilities of this API:

• Input prompt (in JSON):
```json
{
  "prompt": "The photo: Create a cinematic, photorealistic medium shot capturing the nostalgic warmth of a late 90s indie film. The focus is a young woman with brightly dyed pink-gold hair and freckled skin, looking directly and intently into the camera lens with a hopeful yet slightly uncertain smile, she is slightly off-center. She wears an oversized, vintage band t-shirt that says \"API Market\" (slightly worn) over a long-sleeved striped top and simple silver stud earrings. The lighting is soft, golden hour sunlight streaming through a slightly dusty window, creating lens flare and illuminating dust motes in the air. The background shows a blurred, cluttered bedroom with posters on the wall and fairy lights, rendered with a shallow depth of field. Natural film grain, a warm, slightly muted color palette, and sharp focus on her expressive eyes enhance the intimate, authentic feel",
  "aspect_ratio": "16:9",
  "safety_filter_level": "block_medium_and_above"
}
```

• Example output image:  
![Example output image demonstrating the photorealistic capabilities of Imagen-4](https://blog.api.market/wp-content/uploads/2025/06/api_market_imagen_4.jpg)

You can adapt the prompt and parameters to produce various styles, compositions, or subject matter.

## Pricing
- 1 API unit equals 1 image processed.  
- Checking prediction status (GET /api/v1/magicapi/photorealistic-text-to-image-api/predictions/{id}) is free and does not count toward usage.  
- Multiple pricing tiers are available, with costs scaling by volume of image requests.  

## API Documentation

### Base URL
All API requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api
```

### Authentication
Include your API key in the request header:  
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
  
Example (in cURL):
```bash
curl -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
     https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api/predictions
```

### Asynchronous Processing
This API processes image generation requests asynchronously:
1. Send a POST request to create a prediction.  
2. You receive a prediction ID in the response.  
3. Poll the GET endpoint with this prediction ID to check status.  
4. Continue until the API returns "succeeded" or "failed."  

A recommended polling interval is 1 second, with a maximum timeout of 600 seconds (10 minutes).

### Endpoints

#### 1. Create a Prediction
• Method: POST  
• Endpoint:  
  ```
  /api/v1/magicapi/photorealistic-text-to-image-api/predictions
  ```
• Description: Submits a text prompt and relevant parameters for image generation.  

##### Request Body (JSON)
- version (string): Model version ID (default provided below)  
- input (object):  
  - prompt (string, required): Detailed text prompt.  
  - aspect_ratio (string, optional): Defaults to "1:1".  
  - safety_filter_level (string, optional): Defaults to "block_only_high".  

##### Example Request
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "573cdf74dfdf9b1a42fc327a3887f96caa6f1bf90d086511b486792152abb9d9",
    "input": {
      "prompt": "The photo: Create a cinematic, photorealistic medium shot capturing...",
      "aspect_ratio": "16:9",
      "safety_filter_level": "block_medium_and_above"
    }
  }'
```

##### Example Response
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "573cdf74dfdf9b1a42fc327a3887f96caa6f1bf90d086511b486792152abb9d9",
  "status": "starting",
  "created_at": "2025-06-05T19:43:18.144Z"
}
```

#### 2. Get Prediction Status & Results
• Method: GET  
• Endpoint:  
  ```
  /api/v1/magicapi/photorealistic-text-to-image-api/predictions/{id}
  ```
• Description: Checks the status of your image generation request and returns the result if available.  

##### Example Request
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

##### Example Response
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/06/api_market_imagen_4.jpg",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
When `"status"` is `"succeeded"`, `output` will contain a URL to the generated image.

## Status Codes
- 200 OK: Request succeeded.  
- 201 Created: Resource (prediction) successfully created.  
- 400 Bad Request: Invalid or missing request parameters.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: You do not have permissions for this resource.  
- 404 Not Found: Could not find the specified resource.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: An error occurred on the server.  
- 503 Service Unavailable: Service is temporarily unavailable.

## Rate Limits
Requests may be subject to rate limits. If you reach the limit, the API will return 429 Too Many Requests. Implement back-off and retry logic. You can also discuss higher-rate or custom tier limits based on usage volume.

## Error Handling
Error responses are returned in JSON format. Common error response structure:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
- Check the "code" and "message" to determine the cause (e.g., missing parameters or invalid values).
- Retry strategies should handle transient 5xx errors or 429 rate-limit responses by waiting and retrying.

## Implementation Guide

Below are example implementations that showcase how to:
1. Authenticate using your API key  
2. Submit a prediction request  
3. Poll for status  
4. Retrieve results  

### JavaScript Example
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "573cdf74dfdf9b1a42fc327a3887f96caa6f1bf90d086511b486792152abb9d9",
        input: inputData
      })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    // Step 2: Poll for results with timeout
    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; // 10 minutes in ms
  const POLL_INTERVAL = 1000; // 1 second
  
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-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") {
      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/photorealistic-text-to-image-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "573cdf74dfdf9b1a42fc327a3887f96caa6f1bf90d086511b486792152abb9d9",
            "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"]
    
    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

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

    headers = {"x-magicapi-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"] == "failed":
            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
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api/predictions" \
     -H "Content-Type: application/json" \
     -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
     -d '{
       "version": "573cdf74dfdf9b1a42fc327a3887f96caa6f1bf90d086511b486792152abb9d9",
       "input": {
         "prompt": "A realistic image of a cat wearing a top hat"
       }
     }'

# Response example: {"id": "abcd1234", "status": "starting"}

# Step 2: Check the prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-api/predictions/abcd1234" \
     -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Continue polling until "status": "succeeded"
```

### Performance Optimization
- Keep prompt lengths concise but descriptive.  
- Use lower complexity prompts to reduce processing time.  
- Poll at 1-second intervals to avoid excessive requests.

## FAQ
1. **How long does it take to generate an image?**  
   Generation lengths vary based on prompt complexity, but typically range from a few seconds to under a minute.  

2. **What happens if I exceed the 10-minute timeout?**  
   In that case, the request should be considered timed out, and you can try again or optimize your prompt.  

3. **Do GET requests count toward billing?**  
   No. Checking prediction status with GET requests is free.  

4. **Can I reuse the same prompt multiple times?**  
   Yes. Each request is processed independently.

## 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[at]api.market.

Generate high-fidelity, cinematic-quality images from text prompts using Google's Imagen-4 model. Try it free on API.market.

Imagen-4 – Photorealistic Image Generation | $0.05/call | API.market

🎨 Photorealistic Text-to-Image Generator API (Imagen-4)

PAYG

MagicAPI

This is one of the best APi tools for generating text to Images.

Generate high-fidelity, lifelike images from text prompts instantly using Google's advanced Imagen-4 AI model—perfect for creating eye-catching visual content.