Name: Qwen-Image – AI Image Generation | $0.03/call | API.market
Brand: magicapi
SKU: api-magicapi-text-to-image-ai-generator
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🖼️ Next-Gen Text-to-Image Generator API (Qwen-Image 20B)

## Overview
This API transforms text prompts into vivid, high-quality images in seconds, powered by a cutting-edge 20B MMDiT model. Whether you’re creating marketing visuals, generating unique artwork, or prototyping product designs, this text-to-image generator provides fast and reliable results. Simply submit a text prompt and retrieve stunning AI-generated images that bring your ideas to life.

## Features
- Rapid text-to-image generation in seconds  
- High-resolution outputs with multiple aspect ratios  
- Powerful 20B MMDiT model for realistic and creative results  
- Flexible prompts for a wide range of artistic styles and applications  
- Straightforward asynchronous workflow for robust integrations  

## Use Cases
1. e-Commerce Product Visuals: Generate sleek product mockups from textual descriptions, saving photography costs and reducing time-to-market.  
2. Social Media Marketing: Quickly create eye-catching images and ads tailored to campaigns using custom text prompts for maximum engagement.  
3. Publishing & Storytelling: Enhance book covers, illustrations, and editorial pieces with dynamic imagery shaped by narrative or poetry.  
4. UI/UX Prototyping: Visualize design concepts or propose new user interface elements directly from textual specs or brainstorming notes.  
5. Educational & Training Materials: Produce visuals to accompany lesson plans, onboarding manuals, or lecture slides, all derived from text-based content.

## Visual Examples
Below is a sample output image generated by the API based on a poetic prompt. This output was provided in the example OpenAPI schema:

![Sample AI-generated stormy seascape image](https://replicate.delivery/xezq/YVRZWDZpKcreRC6nkFFUelHhRMIlfdDlvUJ65QHAM6xPITPqA/tmprxlz3_yd.jpg)

This image corresponds to a prompt describing a stormy seascape accompanied by text snippets containing a poem.  
You can also provide your own input image links (for variations or more advanced use cases) as shown in the cURL examples later in this documentation:

![Example input image for text-to-image generation](https://example.com/image.jpg)

These examples showcase the capability to generate or transform images according to your specified input data.

## Pricing
- Pay As You Go (PAYG) pricing: only pay for what you use.  
- 1 API unit = 1 image processed.  
- GET requests to check prediction status ("GET /api/v1/magicapi/text-to-image-ai-generator/predictions/{id}") are free and do not count toward API unit usage.  
- No monthly subscription fees or usage limits. You’re charged solely per call.

## API Documentation

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

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```
Make sure to keep your API key confidential.

### Asynchronous Processing
This API operates asynchronously. The workflow is:

1. Make a POST request to create a prediction.  
2. Receive a unique prediction ID in the response.  
3. Poll the GET endpoint using that prediction ID to retrieve the status.  
4. Once the status is "succeeded," the output field will contain the generated image URL(s).  

We recommend:  
- Polling every 1 second (POLL_INTERVAL = 1000 ms).  
- A maximum timeout of 600 seconds (10 minutes).  
- If the status becomes "failed" or exceeds timeout, handle it as an error.

### Endpoints

#### Create a Prediction
• Method: POST  
• Path: /api/v1/magicapi/text-to-image-ai-generator/predictions  
• Description: Creates a new prediction request to generate an image from text.  

Request Body (JSON):
```json
{
  "version": "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
  "input": {
    "prompt": "A photo of a stormy seascape...",
    "aspect_ratio": "1:1"
  }
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-ai-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
    "input": {
      "prompt": "A photo of a stormy seascape, with dramatic clouds."
    }
  }'
```

Example Response (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
  "status": "starting",
  "created_at": "2025-08-17T17:19:37.389Z"
}
```

#### Get Prediction Status/Results
• Method: GET  
• Path: /api/v1/magicapi/text-to-image-ai-generator/predictions/{id}  
• Description: Retrieves the status and, if complete, the result of an existing prediction.  

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

Example Response (HTTP 200) when the prediction is succeeded:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://prod.api.market/files/your_generated_image.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"
}
```

## Status Codes
- 200 OK: Request succeeded.  
- 201 Created: Resource (prediction) created successfully.  
- 400 Bad Request: Invalid data provided; check input parameters.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: API key is valid but lacks necessary permissions.  
- 404 Not Found: The requested resource (prediction ID) does not exist.  
- 429 Too Many Requests: The rate limit has been exceeded; retry after a delay.  
- 500 Internal Server Error: A server-side error occurred; try again.  
- 503 Service Unavailable: The service is temporarily offline or overloaded.

## Rate Limits
While there are no fixed monthly usage limits, the service may enforce a rate limit to ensure stability. If you receive a 429 (Too Many Requests) response, reduce your request frequency and retry after a brief wait.

## Error Handling
When an error occurs, the API responds with an appropriate status code and a JSON error message. For example:

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

To handle errors effectively:
- Check the HTTP status code first.  
- Inspect the “message” field for additional details.  
- Implement retry logic for transient errors (e.g., 429 or 503).  
- For permanent client errors (4xx), rectify your request before retrying.  

## Implementation Guide

### Example Code

#### JavaScript (Node.js) Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-image-ai-generator";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const createResponse = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
        input: inputData
      })
    });

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

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

    // Step 2: Poll for results
    return pollForResults(predictionId);
  } catch (error) {
    console.error("Error creating prediction:", error);
    throw error;
  }
}

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

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

  const startTime = Date.now();

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

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

    const prediction = await statusResponse.json();

    if (prediction.status === "succeeded") {
      // Return the generated image URL(s)
      return prediction.output;
    }

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

    // Wait before polling again
    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-ai-generator"

def create_and_wait_for_prediction(prompt_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    payload = {
        "version": "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
        "input": prompt_data
    }

    create_resp = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json=payload
    )
    if create_resp.status_code != 201 and create_resp.status_code != 200:
        raise Exception(f"API error: {create_resp.status_code} {create_resp.text}")

    prediction = create_resp.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

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

    while time.time() - start_time < MAX_TIMEOUT:
        status_resp = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )
        if status_resp.status_code != 200:
            raise Exception(f"API error: {status_resp.status_code} {status_resp.text}")

        prediction = status_resp.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")
```

#### cURL Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-ai-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "6932d147993b2e4f84308b47f381c6a1565300aa4b5f1d58a01eb0b8cd9a969c",
    "input": {
      "prompt": "A futuristic city skyline at sunset, neon accents, 4K detail"
    }
  }'

# The response will return a prediction ID:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   ...
# }

# Step 2: Poll the prediction status with the ID
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-ai-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat the GET call until the status is "succeeded".
```

### Performance Optimization
- Stick to recommended polling (1-second intervals) to minimize API calls.  
- Supply concise prompts to reduce processing overhead.  
- Cache or store partial results to avoid repetitive generation requests.  
- Use aspect ratios wisely to generate only the image sizes you truly need.  

## FAQ
1. **How long does image generation take?**  
   It typically completes within seconds, but can take up to a couple of minutes depending on server load and prompt complexity.

2. **Can I generate multiple images from a single prompt?**  
   The API currently returns one image URL per prediction request. You can submit multiple prompt variations if you’d like more outputs.

3. **Is there a size limit for the text prompt?**  
   Extremely long prompts may impact processing time. We recommend keeping prompts concise yet descriptive.

4. **Are there any prompt guidelines or restrictions?**  
   Avoid prompts violating acceptable usage policies. Keep content socially acceptable, lawful, and non-abusive.

5. **What image formats are supported?**  
   Generated outputs are typically in JPEG or PNG format.

## 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 with a 20B model. Create vivid, realistic visuals for any application. From $0.03/call. Try it free on API.market.

Qwen-Image – AI Image Generation | $0.03/call | API.market

🖼️ Next-Gen Text-to-Image Generator API (Qwen-Image 20B)

PAYG

MagicAPI

fast and reliable—turns text into sharp, creative images in seconds. great for ads, product mockups, or storytelling visuals.
