Name: HiDream L1 Fast – AI Image Generation | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ultra-fast-ai-image-generator
Availability: InStock
Rating: 5.00 (3 reviews)
Author: API Market

Shashank Agarwal

# ⚡ Ultra-Fast AI Image Generator API (HiDream-L1 Fast)

## Overview
The Ultra-Fast AI Image Generator (HiDream-L1 Fast) is a text-to-image generation API designed to quickly produce high-quality images from text prompts. This optimized version of the HiDream-L1 model supports rapid prototyping and creative projects that require fast turnaround times without sacrificing image fidelity.

- Model Name: prunaai/hidream-l1-fast
- Model Version: f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e

## Features
- Fast Inference Speed: Create images in seconds, ideal for quick experimentation.  
- Flexible Output Format: Choose from PNG, JPG, or WEBP with adjustable quality.  
- Multiple Resolutions: Generate images in various aspect ratios, including square, landscape, and portrait.  
- Custom Seed Control: Optionally set a seed for deterministic outputs or use random seeds for infinite variety.  
- Speed Mode Settings: Balance quality and speed with multiple optimization levels (e.g., “Extra Juiced 🚀” for maximum speed).  

## Use Cases
1. Rapid Prototyping: Design teams can quickly visualize and iterate on creative concepts.  
2. Social Media Content: Marketers can generate engaging visuals for campaigns and announcements.  
3. Storyboarding: Game developers and filmmakers can conceptually visualize scenes and character designs.  
4. Advertising Mockups: Ad agencies can produce high-fidelity concepts before committing to hiring external designers.  
5. Personalized Art: Quick generation of custom art pieces for gifting or home decor.

## Visual Examples

### Example Output
Below is an example output image generated with the prompt:  
"a purple cheetah holding a sign that says 'pip install pruna'."

![Sample output image generated from the prompt: a purple cheetah holding a sign that says 'pip install pruna'](https://replicate.delivery/xezq/JzJr90M35joXJNgpPmpBAVilGvTMXx1Rm0eKk6wbKwexe1CpA/output_10_0.webp)

This showcases how the Ultra-Fast AI Image Generator (HiDream-L1 Fast) can interpret text prompts and produce vibrant visuals with adjustable quality, speed mode, and resolution.

## Pricing
- 1 API unit = 1 image processed  
- GET requests to check prediction status (GET /api/v1/magicapi/ultra-fast-ai-image-generator/predictions/{id}) are free and do not count toward API usage  
- Multiple pricing tiers available to accommodate various usage volumes  

## API Documentation

### Base URL
All requests to this API should be sent to:  
```
https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator
```

### Authentication
Use your assigned API key to authenticate requests. Include this key in the request headers:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API processes image predictions asynchronously. Typical usage flow:

1. Send a POST request to "/predictions" with your input parameters.  
2. Receive an immediate response containing a unique prediction ID.  
3. Poll the GET "/predictions/{id}" endpoint to check status.  
4. When the status changes to "succeeded," download or use the generated output from the response.  

Implementation details for polling:
- Poll the GET endpoint at 1-second intervals.  
- Set a maximum timeout of 600 seconds (10 minutes).  
- Stop polling when status is "failed" or "succeeded" or when the timeout is reached.  

### Endpoints

#### 1) Create a Prediction
• Endpoint:  
  POST /api/v1/magicapi/ultra-fast-ai-image-generator/predictions  

• Description:  
  Creates a new prediction for image generation based on your text prompt and other optional parameters.

• Request Body Parameters (JSON):
```json
{
  "version": "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
  "input": {
    "prompt": "Your text prompt here",
    "model_type": "fast",
    "resolution": "1024 × 1024 (Square)",
    "speed_mode": "Lightly Juiced 🍊 (more consistent)",
    "output_format": "webp",
    "output_quality": 100,
    "seed": -1
  }
}
```
• Sample Request (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
    "input": {
      "prompt": "a purple cheetah holding a sign that says \"pip install pruna\"",
      "model_type": "fast",
      "resolution": "1024 × 1024 (Square)",
      "speed_mode": "Extra Juiced 🚀 (even more speed)",
      "output_format": "webp",
      "output_quality": 80,
      "seed": 10
    }
  }'
```

• Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
  "status": "starting",
  "created_at": "2025-04-20T10:51:01.058Z"
}
```

#### 2) Get Prediction Status & Results
• Endpoint:  
  GET /api/v1/magicapi/ultra-fast-ai-image-generator/predictions/{id}  

• Description:
  Check the status of an existing prediction and retrieve the resulting image when it’s complete.

• Path Parameter:
- id (string): The unique ID you received when creating the prediction.

• Sample Request (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Example Response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://prod.api.market/file/abcdef1234567890/output.webp", 
  "error": null,
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
- `status`: Will be one of "starting", "processing", "succeeded", "failed", or "canceled".  
- `output`: Direct URL to the generated image (only present when status is "succeeded").

## Status Codes
- 200 OK: Request successful.  
- 201 Created: A new resource (prediction) has been created successfully.  
- 400 Bad Request: Invalid input parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: The API key is valid but does not have sufficient permissions.  
- 404 Not Found: The requested resource was not found.  
- 429 Too Many Requests: Rate limit exceeded; try again later.  
- 500 Internal Server Error: The server encountered an issue; try again.  
- 503 Service Unavailable: Temporary overload or maintenance; retry after a delay.

## Rate Limits
This API enforces rate limits to maintain performance and availability. If you exceed rate limits, you will receive a 429 response. Implement backoff and retry strategies to handle such responses gracefully.

## Error Handling
When the API encounters an error, it returns an HTTP status code that indicates the type of error, along with a JSON body describing the issue. Handle these situations by parsing the error message and status code:

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

### Common Errors
- Missing or invalid prompt parameters.  
- Invalid API key (401 Unauthorized).  
- Predictions that fail due to model constraints or unrecognized parameters.  

### Recommended Retry Strategies
- For transient errors such as 429 or 503, implement exponential backoff (e.g., double the wait time each subsequent retry, up to a maximum).  
- For persistent invalid parameter errors, correct input data rather than retrying immediately.

## Implementation Guide

Below are sample implementations in JavaScript, Python, and cURL that illustrate how to:
1. Authenticate using an API key.  
2. Create a prediction (POST).  
3. Poll the GET endpoint for the prediction’s status, with a 1-second interval and a 10-minute timeout.

### Example Code

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator";

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: "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
        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
    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

  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
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator"

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": "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
            "input": input_data
        }
    )

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

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

    # Step 2: Poll for results
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # seconds
    POLL_INTERVAL = 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":
            raise Exception(f"Prediction failed: {prediction.get('error', 'Unknown error')}")

        time.sleep(POLL_INTERVAL)

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

```bash
cURL examples

1) Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "f67f0ec7ef9fe91b74e8a68d34efaa9145bec28675cb190cbff8a70f0490256e",
    "input": {
      "prompt": "a purple cheetah holding a sign that says \"pip install pruna\"",
      "model_type": "fast"
    }
  }'

2) Check status of a prediction (replace PREDICTION_ID with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator/predictions/PREDICTION_ID" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use the "Extra Juiced 🚀" speed mode for the fastest generation times, though it may slightly affect visual quality.  
- Lower output resolution if you require quick drafts or concept art.  
- Use caching or store intermediate results if you plan to generate multiple variations of the same prompt.  

## FAQ
1. What if my request times out?  
   - Use the asynchronous polling mechanism described above. Increase your polling interval if you are hitting server limits.  

2. Can I specify a seed to reproduce the same image again?  
   - Yes. By default, seed is -1 for a randomly generated seed, but providing a specific integer will lead to deterministic outputs.  

3. How can I get the highest-quality image possible?  
   - Use the “Unsqueezed 🍋” setting in speed_mode, choose a high resolution, and set output_format to PNG or JPG with maximum output_quality.  

4. Why is the output slightly different each time even with the same prompt?  
   - Minor variance may occur due to the nature of diffusion-based image models. Setting a fixed seed can reduce this variance.  

5. Are GET request calls to check prediction status billed?  
   - No. Only actual image generation calls (POST /predictions) count toward usage.  

## 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-quality images from text prompts in seconds. Supports multiple resolutions and formats (PNG, JPG, WEBP). Try it free on API.market.

HiDream L1 Fast – AI Image Generation | $0.05/call | API.market

⚡ Ultra-Fast AI Image Generator API (HiDream-L1 Fast)

PAYG

MagicAPI

Amazing API. Works very well. Super fast and cost effective.

Generate high-quality images from text prompts in seconds with the optimized HiDream-L1 Fast model—perfect for rapid prototyping and creative projects.