Image to 3D Model Generator — Photo to 3D Object 🧊

Turn any image into a high-quality 3D object in under a minute — for just cents per model. Drop in a single photo and get back a clean, fully textured 3D model. No GPU, no subscription, no monthly fees — you pay a small fixed price, and only for models you keep.

• 🎯 Quality — detailed, fully textured meshes reconstructed from one ordinary photo.
• 💸 Cheap — from $0.15 per model, pay-as-you-go — a fraction of subscription tools.
• ⚡ Fast — a usable 3D object in about a minute, no render farm and no waiting hours.

Ready for Blender, Unity, Unreal Engine, Godot, three.js / web, AR/VR, and 3D printing — perfect for game assets, e-commerce 3D product views, prototyping, and automated n8n / Make / Zapier workflows and AI agents.

Demo

Source image	Generated 3D model

One photo in, a .glb 3D model out in ~55 seconds — ~200K triangles, fully rotatable. The turntable above is a render of the actual generated file.

👉 Open the generated .glb in an interactive 3D viewer (drag to orbit) — or download the .glb and drop it into Blender, Unity, or Unreal.

Note: the Apify Store and GitHub render this README as static Markdown, so an interactive 3D canvas can't be embedded directly — the animated turntable is the inline preview, and the link above opens the live, rotatable model.

How it works

1. Provide a public image URL — ideally a clear photo of a single object on a plain background.
2. The model reconstructs the object as a textured 3D mesh.
3. The Actor stores the result as a .glb file in the run's dataset and key-value store.
4. Download the model from the output, or pipe the URL into the next step of your workflow (Blender, a game engine, a web viewer, a slicer).

Why this Actor?

• ⚡ Fast — get a usable 3D model in about a minute, no local GPU required (most desktop photogrammetry or manual modeling takes hours).
• 💸 Cheap — from $0.15 per model. Pay only for successful models; failed runs are never charged.
• 🧊 Standard format — outputs GLB (glTF binary), the universal 3D format that imports cleanly into Blender, Unity, Unreal, Godot, three.js, and AR/VR tools.
• 🖼️ Single-image input — no turntable, no multi-angle capture; one good photo is enough.
• 🔌 Automation-ready — call it from the Apify API, n8n, Make, Zapier, LangChain, or any AI agent via MCP.

How it compares

	This Actor	Meshy / Tripo / Rodin
Pricing model	Pay per model (from $0.15)	Monthly subscription / credits
Commitment	None — pay only for what you run	Recurring plan, credits expire
Failed runs	Never charged	Often consume credits
Input	A single image URL	Image or text, varies
Output	GLB (glTF binary)	Varies / export-gated tiers
API & automation	Native Apify API, n8n, Make, Zapier, MCP	Varies / limited

Great when you want image-to-3D on demand without a subscription — ideal for occasional use, automated asset pipelines, and pay-as-you-go scaling.

Input example

{
    "imageUrl": "https://cdn.doggi-dev.net/ofai/plan_plan-cf945bca478a4ad5ac3e48a93130da47/output.jpg"
}

Output example

{
    "modelUrl": "https://api.apify.com/v2/key-value-stores/.../records/model.glb?signature=...",
    "glbUrl": "https://cdn.doggi-dev.net/media-gen-gateway/model_req-abc123.glb",
    "sourceImageUrl": "https://cdn.doggi-dev.net/ofai/plan_plan-cf945bca478a4ad5ac3e48a93130da47/output.jpg",
    "fileSizeBytes": 2483712,
    "requestId": "req-...",
    "contentType": "model/gltf-binary"
}

The model.glb file is also saved in the run's key-value store, so you always get a stable, signed download URL.

What's in the output file

Each run produces a single GLB (glTF 2.0 binary) with geometry, textures, and materials in one self-contained file:

Property	Detail
Format	GLB / glTF 2.0 binary — one self-contained file, nothing to unpack
Geometry	~190K triangles (typically 185K–200K), with vertex normals and UV coordinates
Materials	PBR metallic-roughness — base-color map + metallic-roughness map
Textures	Embedded, 2048×2048, JPEG for opaque maps and PNG where transparency is present
Compatibility	No required glTF extensions — loads as-is in Blender, Unity, Unreal, Godot, three.js, and web/online viewers
File size	Typically ~8–20 MB

No real-world scale: the model is reconstructed from a single image, so it has no inherent units or dimensions — scale it to taste in your tool. Textures are standard JPEG/PNG (not WebP), so the file imports cleanly into engines and viewers that don't support the EXT_texture_webp extension.

Pricing

You are charged per generated 3D model at a price that drops with your Apify plan.

Apify plan	Price per model
Free	$0.20
Bronze	$0.18
Silver	$0.17
Gold / Platinum / Diamond	$0.15

Failed generations are never charged — you only pay for models you actually receive. (Apify also applies its standard tiny platform fees for the Actor start and each dataset record.)

Tips for great results

• One object, plain background — a single, well-lit subject on a clean background reconstructs far better than a busy scene.
• Fill the frame — the object should be the clear focus of the image, not lost in the distance.
• Avoid heavy occlusion — parts hidden behind other objects can't be reconstructed.
• Even lighting — soft, even light avoids baked-in harsh shadows on the texture.

Working with the GLB

.glb is glTF binary — geometry, textures, and materials in one self-contained file. It opens directly in:

• Blender — File → Import → glTF 2.0 (.glb).
• Unity — via glTFast / UnityGLTF.
• Unreal Engine — Import (glTF runtime or the built-in importer).
• Godot — drag the .glb straight into the project.
• three.js / web — GLTFLoader, or preview in any online glTF viewer.
• AR/VR & 3D printing — convert to USDZ for iOS AR, or to STL/3MF for slicing.

Use it from the API

Run and get the model back in one call (waits for the run to finish, then returns the dataset items including modelUrl):

curl -X POST "https://api.apify.com/v2/acts/danitn11~image-to-3d/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "imageUrl": "https://cdn.doggi-dev.net/ofai/plan_plan-cf945bca478a4ad5ac3e48a93130da47/output.jpg" }'

Prefer to start a run and poll asynchronously? Use the standard run endpoint instead, then fetch the dataset when it finishes:

curl -X POST "https://api.apify.com/v2/acts/danitn11~image-to-3d/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "imageUrl": "https://cdn.doggi-dev.net/ofai/plan_plan-cf945bca478a4ad5ac3e48a93130da47/output.jpg" }'

Works the same from the Apify n8n node, Make, Zapier, LangChain, or the Apify MCP server for AI agents.

For the full request/response shape (run-sync, async, polling, downloading the model), see the OpenAPI spec at ./openapi.yaml — import it into Postman, Insomnia, or any OpenAPI client.

Templates & integrations

Drop this Actor into a no-code workflow to automate 3D asset creation end to end. In each tool, search for the Apify connector, authenticate with your Apify API token, and select danitn11/image-to-3d with the action Run Actor (or Run Actor and get dataset items to receive the model URL back).

• n8n — add the Apify node → Run Actor, map imageUrl from a previous step (e.g. a new row in a Sheet or an uploaded product photo), then push the resulting modelUrl to your storage or 3D-viewer node.
• Make.com — use the Apify › Run an Actor module, then a Watch / Get dataset items module to read back modelUrl. Chain into Google Drive, an asset store, or a product page.
• Zapier — trigger (new row, form submission, etc.) → Apify: Run Actor → action (save to Drive, attach to a listing, notify a channel).

Common pattern — automated 3D asset pipeline:

New product photo (Sheet / form / webhook)
  → Run this Actor (imageUrl)
  → Get modelUrl (.glb)
  → Save to asset store / attach to listing / load in a 3D viewer

Use with AI agents (MCP server)

This Actor works as a tool for any MCP-compatible AI agent (Claude, Cursor, VS Code Copilot, custom agents) through Apify's hosted MCP server. Your agent can turn an image into a 3D model as part of a larger task — "build a 3D asset from this photo" — with billing through your Apify account.

Server URL (with this Actor preselected as a tool):

https://mcp.apify.com?tools=danitn11/image-to-3d

Authenticate with OAuth (you'll be redirected on first connect) or an Authorization: Bearer <APIFY_TOKEN> header.

Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=danitn11/image-to-3d" -H "Authorization: Bearer <APIFY_TOKEN>"

Claude Desktop / claude.ai — add a custom connector with the server URL above (OAuth flow handles auth).

Cursor / VS Code — add to .cursor/mcp.json (or "MCP: Open User Configuration" in VS Code):

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=danitn11/image-to-3d",
            "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
        }
    }
}

Local stdio (npx)

{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": ["-y", "@apify/actors-mcp-server", "--tools", "danitn11/image-to-3d"],
            "env": { "APIFY_TOKEN": "<APIFY_TOKEN>" }
        }
    }
}

Then just ask your agent: "Turn this product photo into a 3D model." The agent calls the Actor, waits for the result, and gets back the model URL from the output schema.

FAQ

How long does it take to generate a 3D model? Usually under a minute or two on dedicated GPUs, depending on the image.

What output format do I get? A single GLB (.glb, glTF binary) file containing the mesh and textures — the universal 3D format supported by Blender, Unity, Unreal, Godot, three.js, and AR/VR tools.

What image formats can I use as input? JPG, PNG, and WebP via a publicly accessible, directly downloadable URL.

What kind of image works best? A clear, well-lit photo of a single object on a plain background, filling most of the frame. Busy scenes, heavy occlusion, and tiny subjects reduce quality.

Can I generate more than one model per run? Each run produces one model from one image. To process many images, start one run per image (easy to fan out from n8n, Make, Zapier, or the API).

What model is used? A state-of-the-art image-to-3D reconstruction model, served on dedicated GPUs. You don't need to manage models or infrastructure — just send an image URL and get a .glb back.