Pixal3D image to 3D

About

Pixal3D turns a single picture into a real 3D model. Give it one image and it returns a textured GLB — the binary glTF format that Unity, Unreal, Blender, three.js and every mainstream AR and VR viewer open natively — so what comes back is an asset you can drop into a scene, not another picture of an object.

The mesh arrives at roughly 695,000 triangles carrying a full PBR material set baked from the high-poly reconstruction: base colour, metallic-roughness, normal and ambient occlusion, at 4K, 2K and 1K respectively. That is enough surface information to light the object properly in an engine instead of leaning on the shading that happened to be in the source photo.

It is built on TRELLIS.2 and it always needs a starting image — there is no text-to-3D path here. Sogni runs it as two reconstruction graphs under one model id. The default takes no prompt at all: BiRefNet isolates the subject automatically, so a clean photo of one object is the entire request. The prompted variant swaps that step for SAM 3, so a prompt can name which object in a busy frame to rebuild — and, exactly as with SAM 3 itself, that prompt selects an object rather than describing one.

Five options can only reduce the work: texture size, mesh target faces, normal-map size, ambient-occlusion size and shape resolution. Each already ships at its maximum, so lowering one costs less to produce and can never cost more. Mesh target faces is the one most worth setting — 695K triangles is far heavier than a real-time engine wants, and asking for a fraction of that gives you a more useful asset from the same reconstruction.

Only shape resolution moves the price. A reconstruction at the shipped 1536 costs $0.42; asking for 1024 costs $0.30. In one measured run on an RTX 5090 a 1536 reconstruction took about 122 seconds — a single run rather than a benchmark, and different hardware will behave differently.

Run it from the Sogni app by choosing Pixal3D and uploading an image, or call it by model id from the JavaScript or Python SDK. The reconstruction happens on the Sogni Supernet, a decentralized network of creator GPUs, so you never install a 3D pipeline or rent a 30GB card to try it.

Prompting tips

Pixal3D rebuilds what it can actually see, so nearly all of the quality comes out of the source image rather than out of a prompt:

• One object, fully visible — Frame a single subject with none of it cropped away. Geometry that never appears in the picture has to be invented, and invented geometry is where reconstructions go soft.
• Sharp beats big — A crisp, in-focus photo reconstructs better than a large blurry one. Motion blur and heavy compression artefacts both end up in the mesh.
• Avoid heavy occlusion — Hands, foliage and props in front of the subject become part of the silhouette. Shoot or pick a frame where nothing overlaps the object.
• Even, diffuse light — Baked-in highlights and hard shadows are baked into the base-colour map too. Flat, even lighting gives you a texture you can relight in an engine.
• Name the object only when you need to — The default graph needs no prompt. Reach for the prompted variant when the frame is busy, and remember its prompt selects an object — it does not change how that object looks.
• Ask for fewer triangles — Set meshTargetFaces to whatever your engine actually wants. The 700,000-face default costs the same as 60,000, but 60,000 is the one you can ship.

Two reconstruction graphs, one model id

Both graphs cost the same, take the same options and return the same kind of asset. They differ only in how the subject gets separated from everything else in the frame.

Reduce-only options

Every option below already ships at its maximum, so each one can only ask for less work than you are already paying for. Lowering them never costs more, and only shapeResolution changes the price at all.

Pricing

Use pay-as-you-go Spark packs for each model (1 Spark = $0.005), or choose a flat-rate Sogni plan for credit-free fair-use generation in the app.

Shape resolution is the only option that changes what a reconstruction costs. A request is billed at the cheapest priced point that covers the resolution it will actually run at, so 1024 pays the 1024 rate and anything from 1025 to 1536 pays the 1536 rate.

1 Spark = $0.005. Pay as you go with Spark packs, or generate under fair use on a flat monthly Sogni plan.

API

One Sogni API key reaches every model on the Supernet — call Pixal3D with the exact model id.

import { readFileSync } from 'node:fs';
import { SogniClient } from '@sogni-ai/sogni-client';

const client = await SogniClient.createInstance({
  appId: crypto.randomUUID(),
  apiKey: process.env.SOGNI_API_KEY,
  network: 'fast',
});

const project = await client.projects.create({
  type: 'image',
  modelId: 'pixal3d_int8_i23d',
  positivePrompt: '',
  numberOfMedia: 1,
  startingImage: readFileSync('teapot.jpg'),
  // Reduce-only: every default is already the maximum, so this costs no more.
  meshTargetFaces: 60000,
});

const [url] = await project.waitForCompletion();
console.log(url); // textured .glb — download within 24h

import asyncio, os
from sogni_client import SogniClient

async def main():
    async with await SogniClient.create(
        api_key=os.environ["SOGNI_API_KEY"],
        app_id="pixal3d-example",
    ) as sogni:
        project = await sogni.projects.create(
            type="image",
            model_id="pixal3d_int8_i23d",
            positive_prompt="",
            number_of_media=1,
            starting_image="teapot.jpg",
            # Reduce-only: every default is already the maximum.
            mesh_target_faces=60000,
        )
        for url in await project.wait_for_completion():
            print(url)  # textured .glb

asyncio.run(main())

Call pixal3d_int8_i23d with a source image and no prompt, or name the object with the prompted graph. Image-to-3D is not a Creative Agent tool, so there is no REST workflow alias — use the JavaScript or Python SDK. Full reference at docs.sogni.ai.