hi3d/v3.0-quality/image-to-3d

image-to-3D

HI3D v3.0 Quality API by HI3D

hi3d/v3.0-quality/image-to-3d

Image-to-3d

HI3D v3.0 Quality is the Ultra3D generation at 2048³, resolving thin structures, sharp edges and surface detail that the 1536³ tiers smooth over. One image or up to four views in, a textured mesh out, with PBR maps and GLB/OBJ/STL/FBX/USDZ/3MF output.

HI3D v3.0 Quality is developed by a third-party provider. Atlas Cloud (operated by Atlas Cloud AI LLC) provides access to it and does not own it. All trademarks belong to their respective owners.

INPUT

Image *

You can drag and drop a file or click to upload

MAX:1

Reference Images(0/3)

You can drag and drop a file or click to upload

MAX:3

Multi images bit

Should texture

PBR materials

Shading

Rmbg

Additional Settings

OUTPUT

Idle

Your generated 3D model will appear here

Configure your settings and click Run to get started

Your request will cost $0.017 per run. For $10 you can run this model approximately 588 times.

Parameters

Code Example
import requests
import time

# Step 1: Start image generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "hi3d/v3.0-quality/image-to-3d",  # Required. Model name. options: hi3d/v3.0-quality/image-to-3d
    "image": "example_value",  # Required. The source image, as a public URL or a base64 data URI
    "reference_images": [],  # Additional views of the SAME object, alongside `image` — up to three, for four views in total
    "multi_images_bit": "example_value",  # Which of the four view slots the supplied images fill, as four 0/1 characters (front, back, left, right) — e
    "should_texture": True,  # Generate textures as well as geometry
    "enable_pbr": True,  # Produce PBR maps (metallic, roughness, normal) alongside the base colour
    "shading": 0.5,  # How strongly baked-in lighting is removed from the source image before it becomes texture: 0. (min: 0, max: 1)
    "rmbg": True,  # Remove the input image's background before reconstruction
    "target_polycount": 100000,  # Face count of the generated mesh, 100000-5000000. (min: 100000, max: 5000000)
    "output_format": "glb",  # 3D file format of the generated model. options: glb | obj | stl | fbx | usdz | 3mf
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] == "completed":
            print("Generated image:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

image_url = check_status()

Install

Install the required package for your language.

pip install requests

Authentication

All API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP Headers

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Keep your API key secure

Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.

Submit a request

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Submit a Request

Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.

POST/api/v1/model/generateImage

Request Body

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "hi3d/v3.0-quality/image-to-3d",
    "prompt": "A beautiful landscape with mountains and lake"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

Response

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

Check Status

Poll the prediction endpoint to check the current status of your request.

GET/api/v1/model/prediction/{prediction_id}

Polling Example

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Status Values

processingThe request is still being processed.

completedGeneration is complete. Outputs are available.

succeededGeneration succeeded. Outputs are available.

failedGeneration failed. Check the error field.

Completed Response

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.png"
    ],
    "metrics": {
      "predict_time": 8.3
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Upload Files

Upload files to Atlas Cloud storage and get a URL you can use in your API requests. Use multipart/form-data to upload.

POST/api/v1/model/uploadMedia

Upload Example

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

Response

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

Input Schema

The following parameters are accepted in the request body.

Total: 10Required: 2Optional: 8

modelstringrequired

Model name.

Default: "hi3d/v3.0-quality/image-to-3d"

hi3d/v3.0-quality/image-to-3d

imagestringrequired

The source image, as a public URL or a base64 data URI. Formats: png/jpg/jpeg/webp, up to 20 MB. A single object, evenly lit on a clean background, reconstructs best.

Format: uri

reference_imagesarray[string]

Additional views of the SAME object, alongside `image` — up to three, for four views in total. Supplying the back and sides stops them from being inferred. Each entry is a public URL or a base64 data URI.

Min items: 1Max items: 3

multi_images_bitstring

Which of the four view slots the supplied images fill, as four 0/1 characters (front, back, left, right) — e.g. `1010` for a front and a left shot. The number of 1s must equal the number of images. Defaults to the leading slots (two images become `1100`). Ignored when only one image is given.

should_textureboolean

Generate textures as well as geometry. Turn it off for a bare mesh — faster, though the price is the same.

Default: true

enable_pbrboolean

Produce PBR maps (metallic, roughness, normal) alongside the base colour. Requires `should_texture`.

Default: true

shadingnumber

How strongly baked-in lighting is removed from the source image before it becomes texture: 0.0 keeps the photo's shading, 1.0 flattens it hardest. Requires `should_texture`.

Default: 0.5Min: 0Max: 1

rmbgboolean

Remove the input image's background before reconstruction. Turn it off only when the image is already cut out — a background left in becomes geometry.

Default: true

target_polycountinteger

Face count of the generated mesh, 100000-5000000. Omit it to let HI3D pick. The recommended value for this tier is 2,000,000.

Min: 100000Max: 5000000

output_formatstring

3D file format of the generated model.

Default: "glb"

glbobjstlfbxusdz3mf

Example Request Body

{
  "model": "hi3d/v3.0-quality/image-to-3d",
  "image": "example_image",
  "should_texture": true,
  "enable_pbr": true,
  "shading": 0.5,
  "rmbg": true,
  "output_format": "glb"
}

Output Schema

The API returns a prediction response with the generated output URLs.

codeinteger

messagestring

dataunknown

Example Response

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.png"
  ],
  "metrics": {
    "predict_time": 8.3
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integrates 400+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.

Supported Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ supported clients

Install

npx skills add AtlasCloudAI/atlas-cloud-skills

Setup API Key

Get your API key from the Atlas Cloud dashboard and set it as an environment variable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Capabilities

Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.

Image GenerationGenerate images with models like Nano Banana 2, Z-Image, and more.

Video CreationCreate videos from text or images with Kling, Vidu, Veo, etc.

LLM ChatChat with Qwen, DeepSeek, and other large language models.

Media UploadUpload local files for image editing and image-to-video workflows.

Learn more

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server connects your IDE with 400+ AI models via the Model Context Protocol. Works with any MCP-compatible client.

Supported Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ supported clients

Install

npx -y atlascloud-mcp

Configuration

Add the following configuration to your IDE's MCP settings file.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Available Tools

atlas_generate_imageGenerate images from text prompts.

atlas_generate_videoCreate videos from text or images.

atlas_chatChat with large language models.

atlas_list_modelsBrowse 400+ available AI models.

atlas_quick_generateOne-step content creation with auto model selection.

atlas_upload_mediaUpload local files for API workflows.

Learn more

github.com/AtlasCloudAI/mcp-server

API Schema

{
  "info": {
    "title": "AtlasCloud API",
    "version": "1.0.0",
    "description": "The AtlasCloud API."
  },
  "openapi": "3.0.0",
  "paths": {
    "/api/v1/model/generateImage": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "required": true,
            "schema": {
              "description": "Request ID",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        }
      },
      "x-api-name": "model_result"
    }
  },
  "components": {
    "schemas": {
      "Input": {
        "type": "object",
        "properties": {
          "model": {
            "type": "string",
            "description": "Model name.",
            "default": "hi3d/v3.0-quality/image-to-3d",
            "enum": [
              "hi3d/v3.0-quality/image-to-3d"
            ]
          },
          "image": {
            "type": "string",
            "description": "The source image, as a public URL or a base64 data URI. Formats: png/jpg/jpeg/webp, up to 20 MB. A single object, evenly lit on a clean background, reconstructs best.",
            "format": "uri",
            "x-format": "image",
            "x-accept": ".png,.jpg,.jpeg,.webp",
            "x-ui-component": "uploader"
          },
          "reference_images": {
            "type": "array",
            "description": "Additional views of the SAME object, alongside `image` — up to three, for four views in total. Supplying the back and sides stops them from being inferred. Each entry is a public URL or a base64 data URI.",
            "items": {
              "type": "string",
              "format": "uri",
              "x-format": "image"
            },
            "minItems": 1,
            "maxItems": 3,
            "x-accept": ".png,.jpg,.jpeg,.webp",
            "x-ui-component": "uploader"
          },
          "multi_images_bit": {
            "type": "string",
            "description": "Which of the four view slots the supplied images fill, as four 0/1 characters (front, back, left, right) — e.g. `1010` for a front and a left shot. The number of 1s must equal the number of images. Defaults to the leading slots (two images become `1100`). Ignored when only one image is given.",
            "pattern": "^[01]{4}$",
            "x-ui-component": "input"
          },
          "should_texture": {
            "type": "boolean",
            "description": "Generate textures as well as geometry. Turn it off for a bare mesh — faster, though the price is the same.",
            "default": true,
            "x-ui-component": "switch"
          },
          "enable_pbr": {
            "type": "boolean",
            "description": "Produce PBR maps (metallic, roughness, normal) alongside the base colour. Requires `should_texture`.",
            "default": true,
            "x-ui-component": "switch"
          },
          "shading": {
            "type": "number",
            "description": "How strongly baked-in lighting is removed from the source image before it becomes texture: 0.0 keeps the photo's shading, 1.0 flattens it hardest. Requires `should_texture`.",
            "minimum": 0,
            "maximum": 1,
            "default": 0.5,
            "x-ui-component": "slider"
          },
          "rmbg": {
            "type": "boolean",
            "description": "Remove the input image's background before reconstruction. Turn it off only when the image is already cut out — a background left in becomes geometry.",
            "default": true,
            "x-ui-component": "switch"
          },
          "target_polycount": {
            "type": "integer",
            "description": "Face count of the generated mesh, 100000-5000000. Omit it to let HI3D pick. The recommended value for this tier is 2,000,000.",
            "minimum": 100000,
            "maximum": 5000000,
            "x-ui-component": "slider"
          },
          "output_format": {
            "type": "string",
            "description": "3D file format of the generated model.",
            "default": "glb",
            "enum": [
              "glb",
              "obj",
              "stl",
              "fbx",
              "usdz",
              "3mf"
            ],
            "x-ui-component": "select"
          }
        },
        "required": [
          "model",
          "image"
        ],
        "allOf": [
          {
            "if": {
              "properties": {
                "should_texture": {
                  "const": false
                }
              },
              "required": [
                "should_texture"
              ]
            },
            "then": {
              "properties": {
                "enable_pbr": {
                  "x-hidden": true
                },
                "shading": {
                  "x-hidden": true
                }
              }
            }
          }
        ],
        "x-order-properties": [
          "model",
          "image",
          "reference_images",
          "multi_images_bit",
          "should_texture",
          "enable_pbr",
          "shading",
          "rmbg",
          "target_polycount",
          "output_format"
        ]
      },
      "PredictionResponse": {
        "type": "object",
        "properties": {
          "code": {
            "type": "integer"
          },
          "message": {
            "type": "string"
          },
          "data": {
            "$ref": "#/components/schemas/PredictionData"
          }
        }
      },
      "PredictionData": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique ID of the generation task."
          },
          "model": {
            "type": "string",
            "description": "Model used for the generation."
          },
          "outputs": {
            "type": "array",
            "description": "Generated results: the 3D model file URL first, then the rendered preview image. Null or empty until the task completes.",
            "items": {
              "type": "string"
            }
          },
          "files": {
            "type": "array",
            "description": "Structured metadata for each entry in `outputs`, in the same order, so a client can tell the mesh apart from the preview.",
            "items": {
              "type": "object",
              "properties": {
                "url": {
                  "type": "string"
                },
                "type": {
                  "type": "string",
                  "description": "Logical file kind, e.g. GLB, OBJ, STL, FBX, USDZ, 3MF, PREVIEW."
                },
                "content_type": {
                  "type": "string"
                },
                "file_name": {
                  "type": "string"
                }
              }
            }
          },
          "thumbnail": {
            "type": "string",
            "description": "Rendered preview image of the generated model."
          },
          "urls": {
            "type": "object",
            "properties": {
              "get": {
                "type": "string"
              }
            }
          },
          "status": {
            "type": "string",
            "description": "Current task status, such as created, processing, completed, or failed."
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "error": {
            "type": "string",
            "description": "Error message returned when the task fails."
          }
        }
      }
    }
  },
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ]
}

LLM-Friendly Prompt Template

# hi3d/v3.0-quality/image-to-3d

> HI3D v3.0 Quality is the Ultra3D generation at 2048³, resolving thin structures, sharp edges and surface detail that the 1536³ tiers smooth over. One image or up to four views in, a textured mesh out, with PBR maps and GLB/OBJ/STL/FBX/USDZ/3MF output.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateImage` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `hi3d/v3.0-quality/image-to-3d`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  Model name.
  - Default: `"hi3d/v3.0-quality/image-to-3d"`
  - Options: "hi3d/v3.0-quality/image-to-3d"

- **`image`** (`string`, _required_):
  The source image, as a public URL or a base64 data URI. Formats: png/jpg/jpeg/webp, up to 20 MB. A single object, evenly lit on a clean background, reconstructs best.

- **`reference_images`** (`array[string]`, _optional_):
  Additional views of the SAME object, alongside `image` — up to three, for four views in total. Supplying the back and sides stops them from being inferred. Each entry is a public URL or a base64 data URI.
  - Min items: 1
  - Max items: 3

- **`multi_images_bit`** (`string`, _optional_):
  Which of the four view slots the supplied images fill, as four 0/1 characters (front, back, left, right) — e.g. `1010` for a front and a left shot. The number of 1s must equal the number of images. Defaults to the leading slots (two images become `1100`). Ignored when only one image is given.

- **`should_texture`** (`boolean`, _optional_):
  Generate textures as well as geometry. Turn it off for a bare mesh — faster, though the price is the same.
  - Default: `true`

- **`enable_pbr`** (`boolean`, _optional_):
  Produce PBR maps (metallic, roughness, normal) alongside the base colour. Requires `should_texture`.
  - Default: `true`

- **`shading`** (`number`, _optional_):
  How strongly baked-in lighting is removed from the source image before it becomes texture: 0.0 keeps the photo's shading, 1.0 flattens it hardest. Requires `should_texture`.
  - Default: `0.5`
  - Min: 0
  - Max: 1

- **`rmbg`** (`boolean`, _optional_):
  Remove the input image's background before reconstruction. Turn it off only when the image is already cut out — a background left in becomes geometry.
  - Default: `true`

- **`target_polycount`** (`integer`, _optional_):
  Face count of the generated mesh, 100000-5000000. Omit it to let HI3D pick. The recommended value for this tier is 2,000,000.
  - Min: 100000
  - Max: 5000000

- **`output_format`** (`string`, _optional_):
  3D file format of the generated model.
  - Default: `"glb"`
  - Options: "glb", "obj", "stl", "fbx", "usdz", "3mf"



**Required Parameters Example**:

```json
{
  "model": "hi3d/v3.0-quality/image-to-3d",
  "image": ""
}
```


**Full Example**:

```json
{
  "model": "hi3d/v3.0-quality/image-to-3d",
  "image": "",
  "reference_images": [
    ""
  ],
  "multi_images_bit": "",
  "should_texture": true,
  "enable_pbr": true,
  "shading": 0.5,
  "rmbg": true,
  "target_polycount": 100000,
  "output_format": "glb"
}
```


### Output Schema

The API returns the following output format:


- **`code`** (`integer`, _optional_):

- **`message`** (`string`, _optional_):

- **`data`** (`string`, _optional_):



**Example Response**:

```json
{
  "code": 0,
  "message": "",
  "data": null
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "hi3d/v3.0-quality/image-to-3d",
  "image": "",
  "reference_images": [
    ""
  ],
  "multi_images_bit": "",
  "should_texture": true,
  "enable_pbr": true,
  "shading": 0.5,
  "rmbg": true,
  "target_polycount": 100000,
  "output_format": "glb"
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/hi3d/v3.0-quality/image-to-3d)

No 3D output

HI3D v3.0 Quality

HI3D v3.0 Quality is the Ultra3D generation running at 2048³. The higher voxel resolution resolves thin structures, sharp edges and small surface features that the 1536³ tiers round off. Generation is asynchronous; results are re-hosted on AtlasCloud storage.

Why Choose This?

2048³ geometry — thin structures (handles, straps, antennae) survive instead of fusing into the body.
Sharper edges — hard-surface objects keep their creases rather than being rounded.
Up to four views — back, left and right shots pin down what a single photo cannot show.
PBR out of the box — base colour plus metallic, roughness and normal maps unless you turn them off.
Comparable turnaround to v2.1 Fast — the resolution step does not take you the afternoon.

Parameters

Parameter	Required	Description
`model`	Yes	`hi3d/v3.0-quality/image-to-3d`
`image`	Yes	Source image: public URL or base64 data URI. png/jpg/jpeg/webp, up to 20 MB.
`reference_images`	No	Up to three more views of the same object, for four in total.
`multi_images_bit`	No	Which view slots the images fill, as four 0/1 characters (front, back, left, right). Defaults to the leading slots.
`should_texture`	No	Generate textures as well as geometry. Default: `true`
`enable_pbr`	No	Also produce metallic / roughness / normal maps. Default: `true`. Requires `should_texture`.
`shading`	No	De-lighting strength, `0.0`–`1.0`. Default: `0.5`. Requires `should_texture`.
`rmbg`	No	Remove the input image's background before reconstruction. Default: `true`
`target_polycount`	No	Face count, 100000–5000000. Omit to let HI3D pick; recommended here: 2,000,000.
`output_format`	No	`glb` (default), `obj`, `stl`, `fbx`, `usdz`, `3mf`.

Resolution is fixed at 2048³ Quality for this model and is not a request parameter — each HI3D tier is its own model. To change resolution, call a different model.

How to Use

curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
  -H "Authorization: Bearer $AIP_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "hi3d/v3.0-quality/image-to-3d",
    "image": "https://static.atlascloud.ai/media/images/sneaker.png",
    "should_texture": true,
    "enable_pbr": true,
    "output_format": "glb"
  }'

Multi-view, four photographs of the same object:

curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
  -H "Authorization: Bearer $AIP_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "hi3d/v3.0-quality/image-to-3d",
    "image": "https://static.atlascloud.ai/media/images/sneaker_front.png",
    "reference_images": [
      "https://static.atlascloud.ai/media/images/sneaker_back.png",
      "https://static.atlascloud.ai/media/images/sneaker_left.png",
      "https://static.atlascloud.ai/media/images/sneaker_right.png"
    ]
  }'

Generation is asynchronous — poll /api/v1/model/prediction/{request_id} until status is completed, then read the model URL from outputs. files gives the same URLs with their format and MIME type, and thumbnail is a rendered preview. Expect about 7-10 minutes.

Best Use Cases

Hero product assets — the model a customer rotates and zooms into.
Hard-surface objects — tools, electronics, machinery, where edges must stay edges.
Characters and figurines — fingers, straps and accessories that lower tiers merge.
3D printing — output_format: "stl" or "3mf" with geometry worth printing.

Pro Tips

One object, centred, evenly lit, plain background. Clutter and hard shadows are reconstructed as geometry.
A three-quarter view reconstructs better than a dead-on front or a steep top-down shot.
Shooting the back and sides and passing them as reference_images is the single biggest quality lever — bigger than moving up a tier.
Leave rmbg on unless your image is already cut out against transparency.
Raise shading when the source photo has strong directional light you do not want baked into the texture; lower it when the lighting is already flat.
should_texture: false returns the bare mesh sooner — use it when you are going to texture the model yourself.

Notes

Accepted input formats are png, jpg, jpeg and webp, up to 20 MB each.
reference_images must be views of the same object. Different objects produce a fused, unusable mesh.
multi_images_bit must contain exactly as many 1s as there are images in total (image plus reference_images); a mismatch is rejected before the request reaches HI3D.
enable_pbr and shading only apply when should_texture is on; they are dropped otherwise.
HI3D's own result links expire one hour after generation. The URLs returned here are AtlasCloud-hosted and stay reachable.

HI3D v2.1 Fast — 1536³ Fast.
HI3D v2.1 Pro — 1536³ Pro.
HI3D v3.0 Master — 2048³ Master.

HI3D v3.0 Quality API by HI3D

INPUT

OUTPUT

Parameters

Code Example

Install

Authentication

HTTP Headers

Submit a request

Submit a Request

Request Body

Response

Check Status

Polling Example

Status Values

Completed Response

Upload Files

Upload Example

Response

Input Schema

Example Request Body

Output Schema

Example Response

Atlas Cloud Skills

Supported Clients

Install

Setup API Key

Capabilities

MCP Server

Supported Clients

Install

Configuration

Available Tools

API Schema

LLM-Friendly Prompt Template

HI3D v3.0 Quality

Why Choose This?

Parameters

How to Use

Best Use Cases

Pro Tips

Notes

Related Models

Explore Similar Models

HI3D v3.0 Master

HI3D v2.1 Pro

HI3D v2.1 Fast

GPT Image 2.5 Sunburst Text-to-Image

GPT Image 2.5 Sunburst Edit

GPT Image 2.5 Flare Text-to-Image

GPT Image 2.5 Flare Edit

Openai GPT Image 2 Text-to-Image

Openai GPT Image 2 Edit

GPT Image 2.5 Flare Developer Edit

GPT Image 2.5 Flare Developer Text-to-Image

GPT Image 2.5 Sunburst Developer Edit

GPT Image 2.5 Sunburst Developer Text-to-Image

GPT Image 2 Developer Edit

GPT Image 2 Developer Text-to-Image

Seedream v4.7 Edit Sequential

One API for All Media AI.

INPUT

OUTPUT

Parameters

Code Example

Install

Authentication

HTTP Headers

Submit a request

Submit a Request

Request Body

Response

Check Status

Polling Example

Status Values

Completed Response

Upload Files

Upload Example

Response

Input Schema