Name: Sana – High-Res AI Image Generation | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-high-res-artistic-ai-image-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖌️ Ultra-Fast High-Res AI Image Generator API (Sana)

## Overview
The Ultra-Fast High-Res AI Image Generator API (Sana) enables you to generate stunning, high-resolution images up to 4096×4096 pixels in just a matter of seconds. It empowers developers and AI enthusiasts to create visually impressive and artistically diverse images for various applications. Simply provide your desired prompt, optional negative prompt, model variant, and key parameters (e.g., width, height, guidance scale), and the API returns a high-quality image that meets your specifications.

Below is an example of an output image generated with the prompt "a cyberpunk cat with a neon sign that says 'Sana'":

![Example output: a cyberpunk cat with a neon sign that says Sana](https://blog.api.market/wp-content/uploads/2026/04/high-res-image-gen.png)

## Features
- Generates images up to 4096×4096 pixels at lightning-fast speeds  
- Offers multiple model variants to suit different resolution and language needs  
- Includes fine-grained control over prompts and negative prompts  
- Adjustable inference parameters such as guidance_scale, PAG guidance scale, number of inference steps, seed, and more  
- Supports flexible creative use cases: from concept art and game assets to marketing materials and beyond  

## Use Cases
1. High-Quality Concept Art: Rapidly create ultra-detailed concept art and storyboards for movies, games, and comics.  
2. Marketing Visuals: Produce vibrant advertisements or social media graphics to capture audience attention.  
3. Product & Fashion Design: Quickly iterate on design ideas for products, packaging, or apparel in high resolution.  
4. Architectural and Interior Mockups: Generate compelling visuals for real estate, architectural previews, or interior design concepts.  
5. Artistic Exploration: Experiment with unique styles and techniques for personal projects or creative portfolios.

## Visual Examples
Below are some visual examples that illustrate the API’s capabilities. All images in these examples are generated by providing a textual prompt:

### Example Input Prompt
"a cyberpunk cat with a neon sign that says 'Sana'"

### Example Output
![High-resolution cyberpunk cat artwork with a neon Sana sign](https://blog.api.market/wp-content/uploads/2026/04/high-res-image-gen.png)

## Pricing
- 1 API unit = 1 image processed using the POST /predictions endpoint.  
- GET requests to check the status of a prediction are free and do not count toward API unit usage.  
- Various pricing tiers are available based on your usage volume. Check your API.market account for more details.

## API Documentation

### Base URL
All requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/high-res-artistic-ai-image-generator
```

### Authentication
Use your API key (provided by API.market) in the request header:

```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing. When you create a prediction with a POST request, the API immediately returns a prediction ID. You then poll the GET endpoint with that prediction ID to check the status of your request until it’s complete. The typical flow is:

1. Submit a prediction request (POST /predictions).  
2. Receive a prediction ID.  
3. Poll (GET /predictions/{id}) to check status until your request completes or fails.  
4. When status is "succeeded," retrieve and use the resulting image URL.

Implementation considerations:
- Poll every 1 second to avoid excessive requests.  
- Implement a maximum timeout of 600 seconds (10 minutes).  
- Continue polling while status is "starting" or "processing."  
- Handle errors when status is "failed" or if the process times out.

### Endpoints

#### POST /api/v1/magicapi/high-res-artistic-ai-image-generator/predictions
Creates a prediction (i.e., starts generating an image).

Request Body (JSON):
```json
{
  "version": "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
  "input": {
    "prompt": "a cyberpunk cat with a neon sign that says \"Sana\"",
    "negative_prompt": "",
    "model_variant": "1600M-1024px",
    "width": 1024,
    "height": 1024,
    "num_inference_steps": 18,
    "guidance_scale": 5,
    "pag_guidance_scale": 2,
    "seed": 1
  }
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-res-artistic-ai-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
    "input": {
      "prompt": "a cyberpunk cat with a neon sign that says \"Sana\"",
      "width": 1024,
      "height": 1024,
      "num_inference_steps": 18,
      "guidance_scale": 5,
      "pag_guidance_scale": 2
    }
  }'
```

Successful Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
  "status": "starting",
  "created_at": "2025-04-22T22:38:41.857Z"
}
```

#### GET /api/v1/magicapi/high-res-artistic-ai-image-generator/predictions/{id}
Retrieves the status and result of a prediction. Replace {id} with the prediction ID returned from the POST request.

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

Successful Response (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://example.com/output.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"
}
```

## Status Codes
- 200 OK: Request was successful.  
- 201 Created: Resource was successfully created (e.g., image generation started).  
- 400 Bad Request: The request was invalid (e.g., missing required parameters).  
- 401 Unauthorized: Invalid or missing API key.  
- 403 Forbidden: The API key is valid, but you do not have permission to access this resource.  
- 404 Not Found: The requested resource could not be found (e.g., invalid prediction ID).  
- 429 Too Many Requests: You have exceeded your rate limit.  
- 500 Internal Server Error: An error occurred on the server side.  
- 503 Service Unavailable: The service is temporarily unavailable or under maintenance.

## Rate Limits
Please consult your API.market plan details for rate limit specifics. If you exceed your allocated requests per minute/hour/day, you will receive a 429 Too Many Requests error. In this scenario, reduce your request frequency and/or upgrade your plan.

## Error Handling
When an error occurs, the API returns a JSON response with an error structure. For example:

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

In general:
- Check the HTTP status code.  
- If it is 4XX, correct the request (e.g., fix parameters or authentication).  
- If it is 5XX, retry after a short delay as it may be a temporary server issue.  
- If you receive 429 Too Many Requests, slow down your requests or consider a higher tier.

## Implementation Guide

### Example Code

Below are examples in JavaScript, Python, and cURL showing an end-to-end flow that includes creating a prediction and polling for the result.

#### JavaScript (Node.js)
```javascript
// JavaScript example with proper polling and timeout

const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-res-artistic-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: "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
        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-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");
}

// Example usage:
// createAndWaitForPrediction({
//   prompt: "a cyberpunk cat with a neon sign that says 'Sana'",
//   width: 1024,
//   height: 1024
// })
//   .then(outputUrl => console.log("Generated image URL:", outputUrl))
//   .catch(console.error);
```

#### Python
```python
# Python example with proper polling and timeout

import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-res-artistic-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
    }
    payload = {
        "version": "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
        "input": input_data
    }

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

    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":
            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")

# Example usage:
# result_url = create_and_wait_for_prediction({
#     "prompt": "a cyberpunk cat with a neon sign that says 'Sana'",
#     "width": 1024,
#     "height": 1024
# })
# print("Generated image URL:", result_url)
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/high-res-artistic-ai-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c6b5d2b7459910fec94432e9e1203c3cdce92d6db20f714f1355747990b52fa6",
    "input": {
      "prompt": "a cyberpunk cat with a neon sign that says \"Sana\"",
      "width": 1024,
      "height": 1024
    }
  }'

# Example response:
# {
#   "id": "abcd1234",
#   "status": "starting"
# }

# Step 2: Poll for the prediction status
# (Repeat until "status" is "succeeded" or "failed")
curl -X GET "https://prod.api.market/api/v1/magicapi/high-res-artistic-ai-image-generator/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use the appropriate model variant for your resolution needs (e.g., 512px vs. 1024px).  
- Keep your prompts concise and focused to reduce inference complexity.  
- Only request high-res (4096×4096) if absolutely necessary to control costs and reduce processing time.  

## FAQ
1. How long does it typically take to generate an image?  
   - Most images are generated within seconds to a couple of minutes, depending on resolution and complexity.

2. Can I generate multiple images concurrently?  
   - Yes, you can, but be mindful of your rate limits and concurrency limits specified in your API plan.

3. Is there a limit to how many images I can generate per day?  
   - Your plan dictates the exact limit. Upgrade tiers are available for higher throughput.

4. Can I control the style or theme of images precisely?  
   - The prompt and negative_prompt parameters offer a high degree of control. Experiment with different wordings and parameters like guidance_scale to refine outputs.

5. What if my image doesn’t look right or fails to generate?  
   - Check the error messages in the response. Adjust your prompt, reduce resolution, or try a different model_variant to see if you get better results.

## 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-resolution, artistic AI images from text prompts using the Sana model. Fast and detailed output. From $0.05/call. Try it free on API.market.