Name: Bria 3.2 – Commercial-Ready Images | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-text-to-image-generator-commercial-quality
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ High-Quality Text-to-Image Generator API (bria/image-3.2)

## Overview
This API provides a commercial-quality text-to-image generation service that converts your textual prompts into visually stunning images. Built on a 4B parameter model trained exclusively on licensed data, it delivers exceptional aesthetics, accurate text rendering, and fast performance. The model is evaluated to be on par with leading AI image generators in the market.

## Features
- Generate high-quality images from text prompts
- Commercial-ready, licensed data model
- Exceptional text rendering for precise branding or text elements
- Flexible guidance options (seed, negative prompts, guidance scale)
- Optional prompt enhancement for creative output
- Fine-grained aspect ratio control

## Use Cases
1. E-commerce Product Mockups: Quickly generate visually appealing product shots from textual descriptions to showcase new items in your online store.  
2. Marketing & Advertising: Create promotional material with precise text overlays and brand imagery to capture attention.  
3. Content Creation & Blogging: Enhance articles and social media posts by generating relevant imagery for blog headings or social media campaigns.  
4. Graphic Design Prototyping: Brainstorm and iterate on design concepts without needing manual illustration, saving time in early ideation phases.  
5. Publishing & Education: Produce rapid imagery for educational materials, storybook illustrations, or book covers.

## Visual Examples
Below is an example of a generated image from the prompt "Praying mantis on a wet leaf":

![Output image of a praying mantis perched on a wet leaf](https://blog.api.market/wp-content/uploads/2026/04/Text-to-image-generator.png)

• Input Prompt Example:  
  "prompt": "Praying mantis on a wet leaf"

• Output Image Example:  
  The model produces an image showing a praying mantis in a natural, moody environment on a wet leaf backdrop.

Here’s another example input used in endpoint samples, referencing an illustrative image URL:
![Example input image placeholder](https://example.com/image.jpg)

(You can use such a placeholder in your requests if needed, though in most cases a textual prompt alone is sufficient.)

## Pricing
- Pay As You Go (PAYG): You only pay for what you use.
- 1 API unit = 1 image processed.
- GET requests to check status (GET /api/v1/magicapi/text-to-image-generator-commercial-quality/predictions/{id}) are free.
- No monthly subscription fees or usage limits; simply pay per call.

## API Documentation

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

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

### Asynchronous Processing
This API processes predictions asynchronously. A typical flow looks like this:

1. Send a POST request to create a prediction.  
2. Receive a prediction ID in the response.  
3. Use the prediction ID in repeated GET requests to check the status.  
4. When the status is "succeeded", retrieve and use the generated image.  

Tip: Implement a 1-second polling interval between checks and a 10-minute (600-second) overall timeout.

### Endpoints

#### 1. Create a Prediction
• Method: POST  
• Endpoint: /api/v1/magicapi/text-to-image-generator-commercial-quality/predictions  
• Description: Create a new text-to-image prediction request.

Example Request:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-generator-commercial-quality/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "10ec83a22cded1243cb144902c14a02a8a870c23eea932da52e9c2de72a419ba",
    "input": {
      "prompt": "Praying mantis on a wet leaf",
      "aspect_ratio": "1:1",
      "enhance_image": false
    }
  }'
```

Example Response (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "10ec83a22cded1243cb144902c14a02a8a870c23eea932da52e9c2de72a419ba",
  "status": "starting",
  "created_at": "2025-07-11T07:19:38.264Z"
}
```
Fields:
- id: Unique ID for the prediction request
- version: Model version ID
- status: Prediction status (e.g., "starting")
- created_at: Timestamp of creation

#### 2. Get Prediction Status and Results
• Method: GET  
• Endpoint: /api/v1/magicapi/text-to-image-generator-commercial-quality/predictions/{id}  
• Description: Retrieve the current status of a prediction request and, if available, the output image(s).

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

Example Response (HTTP 200), once succeeded:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/04/Text-to-image-generator.png"
  ],
  "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"
}
```
- output: Array of one or more generated image URLs  
- status: Indicates progress ("starting", "processing", "succeeded", "failed", or "canceled")

## Status Codes
- 200 OK: Request successful.  
- 201 Created: Prediction successfully created.  
- 400 Bad Request: Invalid input parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: Resource not found (invalid prediction ID).  
- 429 Too Many Requests: Rate limit exceeded; retry after some time.  
- 500 Internal Server Error: Server error occurred; retry or contact support.  
- 503 Service Unavailable: Service temporarily overloaded or under maintenance.

## Rate Limits
Information regarding any rate limits (if applicable) would be provided in your API.market account. If you hit a limit, you will receive a 429 Too Many Requests error. Implement exponential backoff or a retry system to handle rate limits gracefully.

## Error Handling
When the API returns an error, the response body typically includes an "error" field detailing the reason. Example:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
Best practices:
- Check status code and error messages for hints about invalid inputs.
- Retry for transient errors (e.g., 429 or 503) with exponential backoff.
- Implement timeouts for long-running requests.

## Implementation Guide

Below are sample workflows illustrating how to integrate this API into your application. Remember to:
1. Create a prediction (POST).
2. Poll for status (GET) until "succeeded" or "failed".
3. Use a 1-second interval between polls, max timeout ~10 minutes.
4. Handle any errors gracefully.

### 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-generator-commercial-quality";

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: "10ec83a22cded1243cb144902c14a02a8a870c23eea932da52e9c2de72a419ba",
        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
  const POLL_INTERVAL = 1000; // 1 second
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    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 Example

```python
import requests
import time

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

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

    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=payload)
    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 with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds
    POLL_INTERVAL = 1  # 1 second
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        headers = {"x-api-market-key": API_KEY}
        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")
```

#### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-generator-commercial-quality/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "10ec83a22cded1243cb144902c14a02a8a870c23eea932da52e9c2de72a419ba",
    "input": {
      "prompt": "Sample prompt text here"
    }
  }'

# The response will include an ID, e.g.:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Poll for status until "succeeded"
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-generator-commercial-quality/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat until the "status" field is "succeeded" or "failed".
```

### Performance Optimization
- Provide short, descriptive prompts to reduce processing time.  
- Use the smallest aspect ratio or resolution that meets your needs to minimize inference duration.  
- Cache results for repeated prompts to avoid redundant requests.

## FAQ
1. **How do I specify an exact size for my image?**  
   Use the aspect_ratio parameter to guide the general shape. The actual output resolution is determined by the model’s internal configuration.

2. **Can I generate multiple images in a single request?**  
   You can repeat the process with different seeds or prompts to get multiple images. A single call typically returns one or more images based on internal settings.

3. **How long does a request usually take?**  
   Typical requests might take a few seconds to complete. Complex prompts may require more time, up to a few minutes.

4. **What if my request fails or times out?**  
   The API returns an error message and a status code. Implement error handling and polling with a 600-second timeout.

5. **Is there any limit to the type of text I can prompt?**  
   We recommend following ethical guidelines and avoiding disallowed content. Check usage policies in your API.market account for more details.

## 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 images from text with accurate text rendering. Trained on 100% licensed data. From $0.05/call. Try it free on API.market.