Name: High-Resolution Text-to-Image Generator API
Brand: magicapi
SKU: api-magicapi-text-to-image-generator-recraft-ai-recraft-v3
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 High-Resolution Text-to-Image Generator API (Recraft V3)

## Overview
The High-Resolution Text-to-Image Generator API (Recraft V3) allows you to generate stunning images from textual descriptions. Recraft V3 (code-named red_panda) is known for rendering long passages of text inside images and for its range of realistic and illustration styles. At its release, Recraft reported it as the top model on the Artificial Analysis Text-to-Image benchmark.

## Features
- 🌟 **State-of-the-Art Image Generation**: Generate high-quality images using advanced AI technology.
- 🎨 **Multiple Styles**: Set `style` to `any` (default), `realistic_image`, `digital_illustration`, or one of 16 sub-styles such as `digital_illustration/pixel_art` and `realistic_image/studio_portrait`.
- 👁️ **Flexible Image Sizing**: Choose one of 15 fixed sizes up to 2048x1024 or 1024x2048, or one of 15 aspect ratios (`size` is ignored when `aspect_ratio` is set).
- 💬 **Text in Images**: Renders long passages of text inside the generated image.
- 🏷️ **Benchmark Results**: At its release, Recraft reported V3 as state of the art on the Artificial Analysis Text-to-Image benchmark.

## Use Cases
1. **E-commerce Product Visualization**:
   - Create compelling product images from descriptions to enhance your online store's visual appeal.
2. **Marketing and Advertising**:
   - Develop eye-catching marketing materials or social media content by converting creative text ideas into stunning visuals.
3. **Content Creation**:
   - Enrich blog posts or multimedia content with custom-generated images that align perfectly with your narrative.
4. **Graphic Design**:
   - Simplify the design process by instantly generating background images, art elements, or complete compositions based on descriptive text.
5. **Educational Materials**:
   - Enhance textbooks, presentations, and e-learning modules with relevant illustrations generated from detailed descriptions.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "a wildlife photography photo of a red panda using a laptop in a snowy forest",
    "size": "1365x1024",
    "style": "any"
  }
}
```

### Example Output

![Example output from High-Resolution Text-to-Image Generator API (Recraft V3)](https://blog.api.market/wp-content/uploads/2026/09/recraft-v3-output-api-market.webp)

This exact request was run through api.market and billed 1 API unit ($0.05).
## Pricing

- **Pay As You Go (PAYG) pricing** - you only pay for what you use
- **Price**: $0.05 per API unit
- **1 API unit = 1 output image**; a request that returns several images is billed for each one
- **Failed or cancelled predictions are not billed**
- GET requests to check prediction status (GET /api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3/predictions/{id}) are free and don’t count toward API unit usage
- **No monthly subscription fee**

## API Documentation

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

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

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

1. Submit a prediction request to the POST endpoint.
2. Receive a prediction ID in the response.
3. Poll the GET endpoint with the prediction ID to check status.
4. Continue polling until the prediction is complete.

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

### Endpoints
#### Create a Prediction
**POST** `/predictions`

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "9507e61ddace8b3a238371b17a61be203747c5081ea6070fecd3c40d27318922",
    "input": {
      "size": "1365x1024",
      "style": "any",
      "prompt": "a wildlife photography photo of a red panda using a laptop in a snowy forest"
    }
  }'
```

#### Check Prediction Status
**GET** `/predictions/{id}`

```bash
# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

#### Input Parameters

| Parameter | Type | Required | Default | Allowed values and notes |
|---|---|---|---|---|
| `prompt` | string | Yes | none | Text prompt for image generation |
| `aspect_ratio` | string | No | `Not set` | `Not set`, `1:1`, `4:3`, `3:4`, `3:2`, `2:3`, `16:9`, `9:16`, `1:2`, `2:1`, `7:5`, `5:7`, `4:5`, `5:4`, `3:5`, `5:3`. When set, `size` is ignored |
| `size` | string | No | `1024x1024` | `1024x1024`, `1365x1024`, `1024x1365`, `1536x1024`, `1024x1536`, `1820x1024`, `1024x1820`, `1024x2048`, `2048x1024`, `1434x1024`, `1024x1434`, `1024x1280`, `1280x1024`, `1024x1707`, `1707x1024` |
| `style` | string | No | `any` | `any`, `realistic_image`, `digital_illustration`, `digital_illustration/pixel_art`, `digital_illustration/hand_drawn`, `digital_illustration/grain`, `digital_illustration/infantile_sketch`, `digital_illustration/2d_art_poster`, `digital_illustration/handmade_3d`, `digital_illustration/hand_drawn_outline`, `digital_illustration/engraving_color`, `digital_illustration/2d_art_poster_2`, `realistic_image/b_and_w`, `realistic_image/hard_flash`, `realistic_image/hdr`, `realistic_image/natural_light`, `realistic_image/studio_portrait`, `realistic_image/enterprise`, `realistic_image/motion_blur` |

Each request returns one image URL in `output`. There is no image input; this model is text-to-image only.

### Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource 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
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

### Rate Limits
Please adhere to the rate limits in place to ensure uninterrupted service. If you encounter rate limiting, consider implementing a backoff strategy to retry after a short delay.

### Error Handling
Proper error handling is crucial for robust API usage. Handle errors as follows:
- **Interpret error responses**: Look for the `"error"` field in the JSON response.
- **Common errors**: Ensure your requests are correctly structured and use valid parameters.
- **Retry strategies**: Implement retries for transient errors such as rate limiting or temporary server issues.

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

## Implementation Guide

### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey,
      },
      body: JSON.stringify({ version: "9507e61ddace8b3a238371b17a61be203747c5081ea6070fecd3c40d27318922", input: inputData })
    });

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

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

    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 between checks

  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" || prediction.status === "canceled") {
      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/text-to-image-generator-recraft-ai-recraft-v3"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY,
    }

    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "9507e61ddace8b3a238371b17a61be203747c5081ea6070fecd3c40d27318922", "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"]

    return poll_for_results(prediction_id)

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

    headers = {"x-api-market-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"] in ("failed", "canceled"):
            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
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "9507e61ddace8b3a238371b17a61be203747c5081ea6070fecd3c40d27318922",
    "input": {
      "size": "1365x1024",
      "style": "any",
      "prompt": "a wildlife photography photo of a red panda using a laptop in a snowy forest"
    }
  }'

# Response will contain a prediction ID like:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-generator-recraft-ai-recraft-v3/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- **Parallel Requests**: There is no batch endpoint. Each prediction returns one image, so send separate requests (in parallel if needed) for multiple images.
- **Efficient Polling**: Implement efficient polling with exponential backoff strategies for optimal performance.
- **Cache Results**: Cache generated images where appropriate to prevent redundant API calls and reduce load.

## FAQ
**Q1**: What kind of text prompts work best with this API?
- **A1**: Detailed and descriptive prompts yield the best results. Specify the style, objects, and scene for higher accuracy.

**Q2**: How long does it take to generate an image?
- **A2**: Typically, it takes a few seconds to a few minutes based on the complexity of the prompt and current server load.

**Q3**: Can I generate multiple images with one request?
- **A3**: No. Each request returns one image. Send one request per image; each image is billed as 1 API unit.

## 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@magicapi.com.

Generate images from text with Recraft V3: realistic and illustration style presets, long in-image text rendering and sizes up to 2048 px.