Name: Bria Expand – Uncrop & Expand Images | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-image-expansion-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ High-Quality Image Expansion API (Bria Expand)

## Overview
The Bria Expand API is designed to seamlessly resize and expand your images beyond their current borders. Using commercially licensed, risk-free AI technology, this service generates new pixels at a high resolution while preserving important details and alpha channels. Whether you want to switch to a different aspect ratio, add more space for design elements, or simply enlarge an image, the API expands your visuals without compromising quality.

![Example of input image for expansion](https://blog.api.market/wp-content/uploads/2026/04/AI-Image-Expansion-.jpg)

## Features
- High-resolution expansion: Generate new pixels for smooth, detailed enlargements.  
- Aspect ratio flexibility: Convert images to square, wide, or tall formats without cropping.  
- Commercially safe usage: Trained exclusively on licensed data for worry-free commercial deployment.  
- Preserves alpha transparency: Keep transparent backgrounds and cut-outs intact after expansion.  
- Customizable output dimensions: Specify exact canvas sizes for your final images.

## Use Cases
1. E-commerce Product Photography  
   Seamlessly extend product images to meet marketplace requirements (e.g., a standardized 16:9 aspect ratio) without needing to crop or compromise the visual appeal.

2. Marketing & Advertising Campaigns  
   When ad platforms require specific dimensions, quickly repurpose existing assets by extending their borders in a high-quality and natural way.

3. Branding & Design  
   Expand your visual branding elements (like logos and banners) so they fit any layout, from web headers to physical print materials.

4. Content Creation & Social Media  
   Transform a single image into different aspect ratios (e.g., 1:1 for Instagram, 9:16 for stories) with minimal effort, ensuring your content is always platform-ready.

5. Film & TV Poster Adaptation  
   Easily adapt poster artworks to different display formats—especially useful for billboards, vertical ads, or custom banners—while maintaining the core artwork.

## Visual Examples
Below is an output example generated by the API, showing how it expands an image to the desired aspect ratio:

![Example of an expanded output image](https://blog.api.market/wp-content/uploads/2026/04/Output-AI-image-expansion-.png)

In this example:
- Input was a moderately sized image with an original 1:1 aspect ratio.  
- Expanded output shows how the image was seamlessly extended to a 16:9 aspect ratio without any visible loss in quality or awkward transitions.

## Pricing
- Pay As You Go (PAYG): Only pay for the exact number of images you process.
- 1 API unit equals 1 image processed.
- GET requests to check prediction status (GET /api/v1/magicapi/ai-image-expansion-api/predictions/{id}) are free.
- No monthly subscription fees or usage limits—simple per-call pricing.

## API Documentation

### Base URL
All requests to this API must be directed to:
```
https://prod.api.market/api/v1/magicapi/ai-image-expansion-api
```

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

### Asynchronous Processing
This API processes image expansions asynchronously. The general flow is:

1. Submit a prediction request (POST /api/v1/magicapi/ai-image-expansion-api/predictions).
2. Receive a prediction ID in the response.
3. Poll the GET endpoint (GET /api/v1/magicapi/ai-image-expansion-api/predictions/{id}) to check the status.
4. When the status is "succeeded," retrieve the final expanded image URL from the response "output" field.

Recommended polling interval is 1 second, with a maximum timeout of 600 seconds. Stop polling if:
- Status becomes "succeeded" → use the output image URL.  
- Status becomes "failed" → handle the error.  

### Endpoints

#### 1. Create a Prediction
• Method: POST  
• Path: /api/v1/magicapi/ai-image-expansion-api/predictions  
• Description: Creates a new image expansion request.

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-image-expansion-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "aspect_ratio": "16:9",
      "sync": false
    }
  }'
```

Example Response (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "21c18eeabca7af7fa8b9ef466e55f6afd3f728a7855de684d5b7c6fac9b732f5",
  "status": "starting",
  "created_at": "2025-07-11T07:19:35.844Z"
}
```
- "id": Unique ID identifying the prediction.
- "status": Can be "starting", "processing", "succeeded", "failed", "canceled".
- "created_at": Timestamp of creation.

#### 2. Check Prediction Status
• Method: GET  
• Path: /api/v1/magicapi/ai-image-expansion-api/predictions/{id}  
• Description: Retrieves the status and (if completed) the result of a prediction.

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

Example Response (HTTP 200, succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://your-output-url.com/expanded-image.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": A URL to the expanded image.  
- "error": Populated if status is "failed".

## Status Codes
- 200 OK: Request was successful.  
- 201 Created: Resource successfully created (e.g., a new prediction).  
- 400 Bad Request: Invalid input or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: API key does not have sufficient permissions.  
- 404 Not Found: The requested resource (e.g., prediction ID) does not exist.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: An error occurred on the server.  
- 503 Service Unavailable: Service is temporarily unavailable or under maintenance.

## Rate Limits
The Bria Expand API may apply rate limiting to ensure fair resource usage. If you encounter a 429 Too Many Requests error, reduce your request rate and implement a brief backoff strategy before retrying.

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

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

- "code": A short code identifying the error type.  
- "message": Descriptive message of what went wrong.  
- "status": The HTTP status code.

Best practices:
- Check the HTTP status code to determine error type.
- Log the "message" to identify which parameter or part of your request is incorrect.
- Implement retries for transient errors, but not for validation or authentication errors.

## Implementation Guide

### Example Code

Below are code samples for creating a prediction and polling the status until completion. Replace YOUR_API_MARKET_KEY with your valid API key.

#### JavaScript (Node.js) Example
```javascript
const fetch = require("node-fetch");

const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-image-expansion-api";

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({ 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 a 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");
}

// Usage example:
// createAndWaitForPrediction({ image: "https://example.com/image.jpg", aspect_ratio: "16:9" })
//   .then(outputUrl => console.log("Expanded image URL:", outputUrl))
//   .catch(err => console.error(err));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-image-expansion-api"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    # Create the prediction
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json={"input": input_data})
    
    if response.status_code != 200 and response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]

    # Poll for results until completion or 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-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"] == "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")

# Usage example:
# expanded_image_url = create_and_wait_for_prediction({
#     "image": "https://example.com/image.jpg",
#     "aspect_ratio": "16:9"
# })
# print("Expanded image URL:", expanded_image_url)
```

#### cURL Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-image-expansion-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "aspect_ratio": "16:9"
    }
  }'

# Sample response:
# {
#   "id": "abcd1234",
#   "status": "starting",
#   ...
# }

# Step 2: Periodically check the prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-image-expansion-api/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Combine multiple expansions in a single pipeline if possible, to reduce repeated requests.  
- Implement caching strategies for images that must be processed more than once.  
- Reduce polling frequency if network usage is a concern, but remain within a reasonable interval to avoid timeouts.

## FAQ
1. Can I preserve transparency in PNGs?  
   Yes. Set "preserve_alpha": true in your request, and the alpha channel is retained in the output.

2. What if the original image is smaller than my target dimensions?  
   The API will intelligently generate new pixels to fill up the larger area, maintaining visual continuity.

3. How do I handle errors or failures?  
   Check the "error" field in the JSON response. If the prediction has "failed," read the error message to see what went wrong. Correct any input issues and re-send your request.

4. Are there constraints on the maximum output size?  
   While there is a practical limit based on processing time, you can typically generate images up to a few thousand pixels in each dimension. If you need unusually large dimensions, contact us via the methods below.

5. Can I use the output commercially?  
   Yes. The model is trained on licensed data, so you can safely use the expanded images in commercial contexts.

## 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.

Expand images beyond their borders or change aspect ratios. Commercially safe AI. From $0.05/call. Try it free on API.market.