Pixal3D single-image + multi-view 3D

About

Pixal3D turns photos into a textured GLB 3D model with baked PBR materials. Start with one image, or use Multi-View to supply a front image plus any combination of left, back, and right views of the same subject. Extra views show the reconstruction surfaces hidden in the front photo.

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.

Built on TRELLIS.2, both workflows require a starting image and take no text prompt. BiRefNet isolates the subject before reconstruction. For Multi-View, use consistent photos of the same object and pose. A front view is required; add one to three other views in their labelled slots. If a photo contains several objects, isolate the intended subject with SAM 3 first.

Four options can only reduce the work: texture size, mesh target faces, normal-map size and ambient-occlusion size. 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.

Single-image and Multi-View reconstructions have the same price: 60 Spark ($0.30) at the default 1024 shape resolution or 84 Spark ($0.42) at 1536. Adding views does not add a per-image charge. Shape resolution is the only reconstruction option that changes the price.

In Sogni Web, open an image and choose Make a 3D model, then add optional photos of its other sides and choose a detail preset. Both workflows run on the Sogni Supernet and are included in eligible Unlimited plans under fair use. You can also call them by exact model ID with the JavaScript or Python SDK.

Choose single-image or Multi-View reconstruction

Both return a textured GLB with the same output controls and prices. Multi-View adds photos of the same object in the left, back, and right slots.

Prompting tips

Pixal3D takes no prompt at all, and it rebuilds what it can actually see — so every bit of the quality comes out of the source image:

• Keep every view consistent — For Multi-View, use photos of the same object in the same pose. Fill the named front, left, back, and right slots rather than mixing unrelated angles or subjects.
• 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.
• Busy frame? Cut it out first — BiRefNet keeps whatever it decides is the foreground, which is the wrong call when several things are in front. Select the object with SAM 3, cut it out on transparency, and reconstruct that instead.
• 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.

Show the sides one photo cannot

Multi-View combines a required front image with one to three optional views of the same subject. Keep the object, pose, and appearance consistent. Left and right mean the subject’s own sides: for the left slot, its own left side faces the camera; for the right slot, its own right side faces the camera. The back slot shows it from behind.

Use Single image when you have only a front photo. Choose Multi-View when you can provide additional views. Both share the same GLB output, PBR maps, detail controls, and $0.30 / $0.42 shape-resolution pricing.

The five options

Four of these already ship at their maximum, so each one can only ask for less work than you are already paying for. shapeResolution is the exception: its default sits at the floor, and raising it is the only thing on this page that costs more.

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 for the variant you want.

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_multiview_int8_i23d',
  positivePrompt: '',
  numberOfMedia: 1,
  startingImage: readFileSync('teapot-front.jpg'),
  leftViewImage: readFileSync('teapot-left.jpg'),
  backViewImage: readFileSync('teapot-back.jpg'),
  // rightViewImage is optional, as are the other side/back views.
  shapeResolution: 1024, // 60 Spark ($0.30), same as single-image
  // Reduce-only: this default is already the maximum, so it 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: this default is already the maximum.
            mesh_target_faces=60000,
        )
        for url in await project.wait_for_completion():
            print(url)  # textured .glb

asyncio.run(main())

The JavaScript example uses pixal3d_multiview_int8_i23d with a front image and optional named leftViewImage, backViewImage, and rightViewImage uploads. Omit unused views; do not pass contextImages. The Python example shows the single-image pixal3d_int8_i23d workflow. Neither workflow takes a text prompt. Full reference at docs.sogni.ai.