Name: Qwen Image – AI Image Generation | $0.03/call | API.market
Brand: magicapi
SKU: api-magicapi-advanced-text-to-image-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 Advanced Text-to-Image Generator API (Qwen Image)

## Overview
The Advanced Text-to-Image Generator (Qwen Image) API instantly transforms complex text prompts into detailed, high-fidelity images. Built on a robust Qwen foundation model, it excels at accurately interpreting intricate textual descriptions—such as titles, signage, or layered contextual elements—and renders them into visually appealing results within seconds.

Key strengths include:
- Precision in rendering detailed text and layered contexts.
- Advanced optimizations for faster generation while preserving quality.
- Flexible aspect ratio and output format support.

## Features
- Generate high-quality images from text prompts with advanced text rendering.  
- Customizable output formats (PNG, JPG, WebP) and aspect ratios.  
- Multiple tuning parameters (guidance, inference steps) to control style, realism, and detail level.  
- Optional performance boost with the "go_fast" parameter.  
- Complete control over randomness using a seed parameter for reproducible results.

## Use Cases
1. E-commerce Product Mockups: Generate realistic product images with promotional text or labels for online stores.  
2. Book Publishing & Marketing: Quickly create compelling book cover imagery with callouts, author photos, and promotional text.  
3. Event Promotion: Produce event flyers and visually appealing banners with textual details (like date, time, and slogans).  
4. Interior Design Visualizations: Convert textual descriptions (e.g., design style and theme) into conceptual images for client pitches.  
5. Educational Infographics: Enrich e-learning content with images that incorporate instructional text or labels for clarity.

## Visual Examples

### Example: Bookstore Window Display
Below is a sample prompt and output that demonstrate how the API renders detailed text and multiple visual elements:

**Prompt (Input)**:
“Bookstore window display. A sign displays ‘New Arrivals This Week’. Below, a shelf tag with the text ‘Best-Selling Novels Here’. To the side, a colorful poster advertises ‘Author Meet And Greet on Saturday’ with a central portrait of the author. There are four books on the bookshelf, namely ‘The light between worlds’, ‘When stars are scattered’, ‘The slient patient’, ‘The night circus’.”

**Generated Output (Sample)**:  
![Sample Output Image for Bookstore Prompt](https://replicate.delivery/xezq/P1UJSMgZsupuHp3eUIOjiZlCVBDrdfQf55A5qZAJvS0OTVPqA/out-0.webp)

## Pricing
- Pay As You Go (PAYG): Only pay for the images you generate.  
- 1 API unit = 1 image processed.  
- GET requests (checking prediction status) are free and do not consume any API units.  
- No monthly subscription fees or usage caps—simple per-call pricing.

## API Documentation

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

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API processes image generation requests asynchronously. The general flow is:
1. POST a new prediction request with your input parameters.  
2. Receive a JSON response containing a unique prediction ID.  
3. Poll the GET endpoint with your prediction ID to check the current status.  
4. When the status is "succeeded", the output array contains direct links to your generated images.

Implementation details:  
- Use a 1-second interval between status checks.  
- Implement a maximum timeout of 600 seconds (10 minutes).  
- Stop polling when status is "succeeded" or "failed".  

### Endpoints

#### Create a Prediction
```
POST /api/v1/magicapi/advanced-text-to-image-generator/predictions
```
- Description: Creates a new text-to-image generation request.  
- Request Body:
  ```json
  {
    "version": "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
    "input": {
      "prompt": "Your descriptive prompt here",
      "aspect_ratio": "16:9",
      "go_fast": true,
      "guidance": 4,
      "output_format": "webp",
      "output_quality": 80,
      "num_inference_steps": 50,
      "seed": 1,
      "enhance_prompt": false,
      "disable_safety_checker": false
    }
  }
  ```
- Example cURL:
  ```bash
  curl -X POST "https://prod.api.market/api/v1/magicapi/advanced-text-to-image-generator/predictions" \
    -H "Content-Type: application/json" \
    -H "x-api-market-key: YOUR_API_MARKET_KEY" \
    -d '{
      "version": "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
      "input": {
        "prompt": "Bookstore window display...",
        "aspect_ratio": "16:9",
        "go_fast": true,
        "guidance": 4,
        "output_format": "webp",
        "output_quality": 80,
        "num_inference_steps": 50
      }
    }'
  ```
- Example Response (201 Created):
  ```json
  {
    "id": "ufawqhfynnddngldkgtslldrkq",
    "version": "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
    "status": "starting",
    "created_at": "2025-08-17T16:27:31.142Z"
  }
  ```

#### Retrieve Prediction Status / Results
```
GET /api/v1/magicapi/advanced-text-to-image-generator/predictions/{id}
```
- Description: Retrieves the current status and results of an image generation request by ID.  
- Example cURL:
  ```bash
  curl -X GET "https://prod.api.market/api/v1/magicapi/advanced-text-to-image-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
    -H "x-api-market-key: YOUR_API_MARKET_KEY"
  ```
- Example Response (200 OK):
  ```json
  {
    "id": "ufawqhfynnddngldkgtslldrkq",
    "status": "succeeded",
    "output": [
      "https://somecdn.com/output-image.webp"
    ],
    "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 Codes
- 200 OK: Request processed successfully.  
- 201 Created: Resource (prediction) has been successfully initiated.  
- 400 Bad Request: Invalid input or malformed request.  
- 401 Unauthorized: Incorrect or missing API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: The specified resource does not exist.  
- 429 Too Many Requests: Rate limit exceeded; slow down requests or retry later.  
- 500 Internal Server Error: An error occurred on the server.  
- 503 Service Unavailable: Service is temporarily offline/maintenance.

## Rate Limits
If you send too many requests in a short period, you may receive a 429 Too Many Requests response. In that case, wait briefly before retrying. Implement exponential backoff (1s, 2s, 4s, etc.) to handle rate limits gracefully.

## Error Handling
Errors typically include a JSON body describing the issue. For example:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
- Always check the HTTP status code.  
- On 400-level errors, verify your request parameters and try again.  
- On 500-level errors, implement retries with backoff in case the issue is temporary.

## Implementation Guide

### Example Code

#### JavaScript (Node.js)
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/advanced-text-to-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-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
        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; // 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-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") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

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

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/advanced-text-to-image-generator"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
            "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  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second

    start_time = time.time()

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

        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"]
        elif 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
```bash
# 1. Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/advanced-text-to-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "d76ca3b70663acfaec35d847bb8f49d3d01f431467040990076da23d90a94b84",
    "input": {
      "prompt": "A futuristic cityscape at sunset...",
      "aspect_ratio": "16:9"
    }
  }'

# Example response:
# {"id": "abcd1234", "status": "starting", "created_at": "2025-08-17T16:27:31.142Z"}

# 2. Poll for the status until it's "succeeded"
curl -X GET "https://prod.api.market/api/v1/magicapi/advanced-text-to-image-generator/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use the "go_fast" parameter if slightly lower image quality is acceptable for faster results.  
- Lowering "num_inference_steps" can further shorten generation time at the cost of some quality.  
- If your prompts don’t require high detail, reduce "guidance" to 2 or 3 to speed up processing and reduce cost.

## FAQ
1. **How many images can I generate at once?**  
   You can create predictions one at a time or in parallel, depending on your integration approach and concurrency needs. Each request returns one or more images based on your prompt.

2. **Is there a limit on text prompt length?**  
   While there's no strict maximum, extremely long prompts may take longer to process. For best results, keep prompts concise yet descriptive.

3. **How do I control image size?**  
   Use the "aspect_ratio" parameter to specify the shape. The API automatically scales resolution to produce visually optimized images.

4. **What happens if the generation takes too long?**  
   Implement polling with a 10-minute timeout. If your request is still not done by then (which is rare), handle it as a failed request and decide whether to retry.

5. **Can I set a seed for reproducible results?**  
   Yes. The "seed" parameter ensures you can recreate the same image given the same inputs.

## 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 detailed, high-fidelity images from complex text prompts in seconds. Renders text within images. From $0.03/call. Try it free on API.market.