Name: Trellis – 2D Image to 3D Assets | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-3d-asset-generator-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧱 High-Quality 3D Asset Generator API (Trellis)

## Overview
The High-Quality 3D Asset Generator API (Trellis) enables you to transform standard 2D images into detailed 3D assets quickly and efficiently. It uses advanced AI-driven 3D modeling techniques, perfect for gaming, augmented reality, virtual reality, product design, and prototyping. With Trellis, you can generate production-ready 3D models, color video previews, and even point cloud data, all from your input images.

## Features
- Converts 2D images into 3D models (GLB file) with optional mesh simplification.  
- Generates additional video previews (color, normal, or combined) to quickly assess your 3D output.  
- Supports randomizing the seed for more variability and experimentation.  
- Offers an option to remove backgrounds from the input images.  
- Returns a point cloud (PLY file) for advanced rendering or editing needs (optional).  

## Use Cases
1. **Game Asset Creation**: Quickly generate in-game 3D items or characters from concept art.  
2. **AR/VR Prototyping**: Rapidly design immersive content for augmented or virtual reality.  
3. **Product Visualization**: Convert product images into interactive 3D representations for marketing or e-commerce.  
4. **Film & Animation**: Speed up pre-visualization by turning concept art into rough 3D previews.  
5. **Educational & Training Materials**: Create interactive 3D models for e-learning platforms.

## Visual Examples

Below is an example of an input image used to generate a 3D model with Trellis:

![Example input image for 3D asset generation with Trellis](https://replicate.delivery/pbxt/MJaYRxQMgIzPsALScNadsZFCXR2h1n97xBzhRinmUQw9aw25/ephemeros_a_dune_sandworm_with_black_background_de398ce7-2276-4634-8f1d-c4ed2423cda4.png)

• Alt text: A dune sandworm with a black background.  
• This input can be processed to produce 3D models, color video previews, and more.

## Pricing
- 1 API unit equals processing 1 image.  
- GET requests to check prediction status (GET /api/v1/magicapi/3d-asset-generator-api/predictions/{id}) are free and do not count toward usage.  
- Different pricing tiers are available based on usage volume.

## API Documentation

### Base URL
All requests to this API should be directed to:  
```
https://prod.api.market/api/v1/magicapi/3d-asset-generator-api
```

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Replace YOUR_API_MARKET_KEY with your actual key provided by API.market.

### Asynchronous Processing
This API uses an asynchronous prediction workflow:
1. Create a prediction using the POST endpoint.  
2. Receive a prediction ID in the response.  
3. Poll the GET endpoint with the provided ID to check status.  
4. Once the status is "succeeded," the 3D model and other outputs are ready.  

Typical processing times depend on the complexity of your images and requested outputs. We recommend:
- Polling every 1 second.  
- A maximum timeout of 600 seconds (10 minutes).  
- Stopping polling upon "succeeded" or "failed" status.

### Endpoints

#### Create a Prediction
• Method: POST  
• Endpoint:  
```
/api/v1/magicapi/3d-asset-generator-api/predictions
```
Use this endpoint to initiate a new 3D asset generation.

Example request (JSON):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/3d-asset-generator-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4876f2a8da1c544772dffa32e8889da4a1bab3a1f5c1937bfcfccb99ae347251",
    "input": {
      "images": [
        "https://replicate.delivery/pbxt/MJaYRxQMgIzPsALScNadsZFCXR2h1n97xBzhRinmUQw9aw25/ephemeros_a_dune_sandworm_with_black_background_de398ce7-2276-4634-8f1d-c4ed2423cda4.png"
      ],
      "generate_color": true,
      "generate_normal": false,
      "generate_model": true,
      "mesh_simplify": 0.9,
      "texture_size": 2048,
      "save_gaussian_ply": true,
      "randomize_seed": true,
      "ss_sampling_steps": 38,
      "slat_sampling_steps": 12,
      "ss_guidance_strength": 7.5,
      "slat_guidance_strength": 3
    }
  }'
```

Example response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "4876f2a8da1c544772dffa32e8889da4a1bab3a1f5c1937bfcfccb99ae347251",
  "status": "starting",
  "created_at": "2025-04-23T20:02:06.702Z"
}
```

#### Check Prediction Status / Retrieve Results
• Method: GET  
• Endpoint:  
```
/api/v1/magicapi/3d-asset-generator-api/predictions/{id}
```
Replace {id} with the prediction ID you received from the POST response. This endpoint returns the status of your prediction and, if completed, the URLs to your 3D model and other generated files.

Example request (JSON):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/3d-asset-generator-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example response (JSON) if prediction has succeeded:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": {
    "model_file": "https://replicate.delivery/yhqm/5xOmxKPXDTpnIdxRRvs91WKWHTYNGmdBjuE7DbBEigZf0WCKA/output.glb",
    "color_video": "https://replicate.delivery/yhqm/wJejQmfsfyNf3T4soquMhYLR34F07LESybQQsy8iYmy2n2SQB/output_color.mp4",
    "gaussian_ply": "https://replicate.delivery/yhqm/tjyjYewq6fj2xUkco7MnifmmL2CeHG3Wfl7Zw5vdxwu0PtlgC/output_gaussian.ply",
    "normal_video": null,
    "combined_video": null,
    "no_background_images": 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**: The resource (prediction) was created successfully.  
- **400 Bad Request**: Invalid input or malformed request (e.g., images field missing).  
- **401 Unauthorized**: Invalid or missing API key.  
- **403 Forbidden**: API key is valid but lacks sufficient permissions.  
- **404 Not Found**: The requested resource (e.g., prediction ID) does not exist.  
- **429 Too Many Requests**: Rate limit reached. Consider implementing backoff retry.  
- **500 Internal Server Error**: The service encountered an unexpected issue.  
- **503 Service Unavailable**: The API is temporarily offline or overloaded.

## Rate Limits
Depending on your plan, there may be a maximum number of requests allowed per second or day. If you hit a rate limit, you will receive a 429 Too Many Requests response. In this case, you should implement exponential backoff and retry logic.

## Error Handling
When an error occurs, the API responds with a JSON object containing details about the error. Your code should handle these errors appropriately.

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

Recommended steps:
- Inspect the error.code and error.message to determine the cause.  
- If it is a missing parameter, ensure your request body includes all required fields.  
- For transient errors (e.g., 503 Service Unavailable), implement retry logic with exponential backoff.

## Implementation Guide

Below are code snippets in common programming languages demonstrating how to create a prediction, poll for results, and handle errors or timeouts.

### Example Code

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/3d-asset-generator-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-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "4876f2a8da1c544772dffa32e8889da4a1bab3a1f5c1937bfcfccb99ae347251",
        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");
}
```

```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/3d-asset-generator-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }

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

    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 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")
```

```bash
# cURL example

# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/3d-asset-generator-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4876f2a8da1c544772dffa32e8889da4a1bab3a1f5c1937bfcfccb99ae347251",
    "input": {
      "images": [
        "https://replicate.delivery/pbxt/MJaYRxQMgIzPsALScNadsZFCXR2h1n97xBzhRinmUQw9aw25/ephemeros_a_dune_sandworm_with_black_background_de398ce7-2276-4634-8f1d-c4ed2423cda4.png"
      ],
      "generate_color": true,
      "generate_normal": false,
      "generate_model": true
    }
  }'

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

# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/3d-asset-generator-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Continue polling until status is "succeeded"
```

### Performance Optimization
To reduce costs and improve performance:
- Provide only essential images for asset creation.  
- Use mesh_simplify if your final application can accept a simpler model.  
- Optimize rate limits by batching requests where possible.  
- Cache or store successful predictions so you don’t have to re-run them.  

## FAQ
1. **How many images can I upload for a single request?**  
   Trellis can handle multiple images. Note that each image counts toward your API usage.  

2. **What file formats are supported for output?**  
   Currently, Trellis outputs GLB for 3D models, MP4 for video previews, and PLY for point cloud data.  

3. **How long does a typical request take?**  
   It depends on the image complexity. Simple objects may take 10–30 seconds, while very complex scenes can take longer.  

4. **What if my request fails?**  
   Failed requests typically return an error message. Review the error details and your input configuration, then retry with adjustments.  

5. **Can I generate a 3D model without the color or normal videos?**  
   Yes. You can disable the color or normal video generation by setting "generate_color": false or "generate_normal": false.

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

Transform 2D images into detailed 3D assets for games and AR. Generates production-ready 3D models (GLB) and video previews. Start free on API.market.

Trellis – 2D Image to 3D Assets | Free · $5/mo | API.market

🧱 High-Quality 3D Asset Generator API (Trellis)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Rapidly create detailed 3D assets for games, AR & design with Trellis—state-of-the-art AI for fast, production-ready results.