Evaluating a photogrammetry API vs Tripo for adding image-to-3D generation to your product pipeline? Here is what changes: PixelAPI's photogrammetry API (also called the i23d API) reconstructs a fully textured 3D model from a single photo, returning your choice of GLB, OBJ, FBX, USDZ, or STL with PBR, Shaded, or no-material output. At $4.495 per model, it is cost-plus pricing with no monthly subscription and an automatic credit refund if generation fails.
Sign up and upgrade to any paid plan. POST your image to /v1/image-to-3d with an optional format and material parameter. Poll GET /v1/image-to-3d/{generation_id} until status=completed, then download your 3D file from output_url.
# Step 1 — submit image
curl -X POST https://api.pixelapi.dev/v1/image-to-3d \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "image=@product.jpg" \
-F "format=glb" \
-F "material=PBR"
# Response: {"generation_id": "uuid", "status": "processing", "estimated_seconds": 180}
# Step 2 — poll until completed (~3 min)
curl https://api.pixelapi.dev/v1/image-to-3d/UUID \
-H "Authorization: Bearer YOUR_API_KEY"
# Response: {"status": "completed", "output_url": "https://..."}
pip install pixelapi
---
import time
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
# Submit
job = client.image_to_3d(
image="product.jpg",
format="glb", # glb | obj | fbx | usdz | stl
material="PBR", # PBR | Shaded | All | None
prompt="product photo, clean background"
)
generation_id = job["generation_id"]
# Poll
while True:
result = client.get_generation(generation_id)
if result["status"] == "completed":
client.download(result["output_url"], "product.glb")
break
if result["status"] == "failed":
print("Failed — credits refunded:", result["error_message"])
break
time.sleep(15)
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
import { setTimeout } from "timers/promises";
const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
const job = await client.imageTo3D({
image: "./product.jpg",
format: "glb",
material: "PBR",
});
let result;
while (true) {
result = await client.getGeneration(job.generation_id);
if (result.status === "completed") break;
if (result.status === "failed") throw new Error(result.error_message);
await setTimeout(15000);
}
await result.save("product.glb");
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;
$client = new Client(getenv("PIXELAPI_KEY"));
$job = $client->imageTo3D([
"image" => "product.jpg",
"format" => "glb",
"material" => "PBR",
]);
do {
sleep(15);
$result = $client->getGeneration($job["generation_id"]);
} while ($result["status"] === "processing");
if ($result["status"] === "completed") {
file_put_contents("product.glb", $client->download($result["output_url"]));
}
gem install pixelapi
---
require "pixelapi"
client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
job = client.image_to_3d(image: "product.jpg", format: "glb", material: "PBR")
loop do
sleep 15
result = client.get_generation(job["generation_id"])
break if result["status"] == "completed"
raise result["error_message"] if result["status"] == "failed"
end
File.binwrite("product.glb", client.download(result["output_url"]))
go get github.com/pixelapi/pixelapi-go
---
import (
"time"
"github.com/pixelapi/pixelapi-go"
)
client := pixelapi.New("YOUR_API_KEY")
job, err := client.ImageTo3D("product.jpg", pixelapi.ImageTo3DOptions{
Format: "glb",
Material: "PBR",
})
if err != nil { panic(err) }
for {
time.Sleep(15 * time.Second)
result, err := client.GetGeneration(job.GenerationID)
if err != nil { panic(err) }
if result.Status == "completed" {
result.Save("product.glb")
break
}
if result.Status == "failed" {
panic(result.ErrorMessage)
}
}
The table below compares PixelAPI's photogrammetry API (i23d) against Tripo and other image-to-3D rivals. PixelAPI uses cost-plus pricing covering provider fees, taxes, processing, and the auto-refund guarantee. Tripo3D is flat per-call; Meshy and Rodin use subscription-pooled credits.
| Provider | Free tier | Per-model cost | Output formats | Subscription required |
|---|---|---|---|---|
| PixelAPI (i23d) | Paid plan required | $4.495 | GLB · OBJ · FBX · USDZ · STL | Paid plan, no monthly minimum |
| Tripo3D | None on API | $0.20 (no texture) · $0.30 (standard texture) | GLB · OBJ · FBX · STL | None — flat per-call |
| Meshy | Free tier available | $0.10/model (10 credits at $0.01/credit) | GLB · FBX · USDZ · OBJ | Subscription (Pro $20/mo for 2,000 credits) |
| Rodin (fal.ai) | None on API | $0.40 (base) · $1.20 (HighPack 4K) | GLB (default), others via settings | None on fal.ai; $120/mo for native API |
| CSM | See csm.ai/pricing | See csm.ai/pricing | GLB · OBJ | See csm.ai/pricing |
Pricing verified from each rival's public pricing page, November 2026. Tripo3D: developers.tripo3d.ai ($0.20 no-texture, $0.30 standard texture per model). Meshy: docs.meshy.ai/en/api/pricing (10 credits at $0.01/credit = $0.10/model). Rodin: fal.ai ($0.40/generation base tier stated on model page). CSM.ai: site unreachable during verification — see csm.ai/pricing. PixelAPI cost-plus pricing reflects provider cost, 18% RCM tax, forex, overhead, and margin; failed jobs are refunded automatically.
The photogrammetry API returns a downloadable 3D file at output_url. The exact format and material mode depend on your request parameters.
Binary glTF. Ready for Three.js, Babylon.js, React Three Fiber, Unity, Unreal, and iOS/Android AR frameworks with no conversion step. The smallest of the mesh+texture bundles.
Pass format=usdz for direct AR Quick Look support on iOS Safari and macOS. Users tap a link and preview the product in their room without an app install.
Pass format=fbx for Unity, Unreal Engine, and the Autodesk suite. FBX carries rigging-compatible bone structure even for static meshes, useful when you plan to add animation later.
Pass format=obj for the widest software compatibility — Blender, Cinema 4D, Maya, 3ds Max, ZBrush, and virtually every renderer accept OBJ without plugins.
Pass format=stl for direct slicer import (PrusaSlicer, Cura, Bambu Studio). No texture data — pure geometry optimised for layer-by-layer printing.
The default material=PBR mode generates physically-based albedo, roughness, metalness, and normal maps. Use material=Shaded for pre-baked diffuse-only textures, or material=None for a clean geometry-only mesh.
| Parameter | Type | Default | Values / notes |
|---|---|---|---|
image | file / URL / base64 | required | Multipart field, image_url, or image_base64. PNG, JPG, WebP. Max 10 MB, min 256 px shortest side. |
format | string | glb | glb · obj · fbx · usdz · stl |
material | string | PBR | PBR · Shaded · All · None |
prompt | string | optional | Up to 400 characters. Soft text guide for the mesh — e.g. "sneaker, side view, clean background". |
The photogrammetry API is the foundation for these production use cases. Each links to a full setup guide:
Turn catalog photos into embeddable 3D viewers. GLB output drops straight into Shopify, BigCommerce, and WooCommerce product pages.
USDZ output powers iOS AR Quick Look — shoppers preview furniture, shoes, and electronics in their room before buying.
FBX output with PBR materials imports directly into Unity and Unreal. Rapid concept-to-asset pipeline for indie and AA studios.
Batch-process product SKUs overnight. Webhook callbacks, async polling, and auto-refund on failure all built in.
Combine background removal + photogrammetry in one API account for clean isolated product shots and their AR counterparts.
Scale 3D catalog production. Upload a product photo, receive a GLB; no 3D artist required for base meshes.
Auto-generate GLB or USDZ for every product image on upload. Powers Shopify's native 3D and AR Quick Look features.
No-code 3D model trigger from new Shopify products, Airtable rows, or Google Drive uploads.
Visual drag-and-drop 3D generation in Make scenarios — connect to any data source.
CMS-driven 3D viewer embeds for Webflow product and collection pages.
BigCommerce product API + PixelAPI image-to-3D for automatic 3D catalog enrichment.
WordPress plugin pattern for per-product GLB generation on first view or publish.
Tripo3D is more affordable at $0.20–$0.30/model. PixelAPI offers more output format choices (5 vs 4), explicit PBR material modes, and an auto-refund guarantee if generation fails.
PixelAPI gives 5 output formats and no fal.ai dependency. Rodin wins on per-model price at $0.40 (base). Choose PixelAPI when you need USDZ + STL + PBR in the same account as your other image tools.
Meshy is cheaper per model ($0.10) on a subscription plan. PixelAPI is pay-per-use with no monthly commitment — better for irregular 3D needs and teams that want one API account for all media.
CSM (now part of Google) offers GLB and OBJ output. PixelAPI adds FBX, USDZ, and STL and keeps billing under one account with your existing image pipeline.
The photogrammetry API enforces a maximum of 2 concurrent generation jobs per account at any time (across all paid plans). Submitting a third concurrent job while two are still processing returns HTTP 429 with code: "too_many_inflight". Standard rate limits by plan tier also apply:
| Plan | Requests / min | Max concurrent 3D jobs |
|---|---|---|
| Starter | 60 | 2 |
| Pro | 120 | 2 |
| Scale | 300 | 2 |
Rate limit errors return HTTP 429 with a Retry-After header. Inflight limit errors include credits_charged: 0 — no credits are spent when the job is rejected before submission. Use exponential backoff starting at 15 seconds for polling and 2 seconds for submission retries.
# Submission with retry in Python
import time, httpx
def submit_with_retry(api_key, image_path, max_attempts=3):
for attempt in range(max_attempts):
resp = httpx.post(
"https://api.pixelapi.dev/v1/image-to-3d",
headers={"Authorization": f"Bearer {api_key}"},
files={"image": open(image_path, "rb")},
data={"format": "glb", "material": "PBR"},
)
if resp.status_code == 429 and "too_many_inflight" in resp.text:
time.sleep(30 * (attempt + 1)) # wait for inflight slot
continue
resp.raise_for_status()
return resp.json()
raise RuntimeError("Max submission attempts exceeded")
If a generation ends in status=failed, credits are automatically refunded. Poll the generation endpoint to confirm — the response will show the error message and confirm that you were not charged.
A photogrammetry API reconstructs a 3D model from one or more photographs via a REST endpoint. PixelAPI's implementation — also called the i23d API — takes a single product photo and returns a fully textured 3D mesh (GLB, OBJ, FBX, USDZ, or STL) with PBR materials. POST to /v1/image-to-3d, receive a generation_id, and poll GET /v1/image-to-3d/{generation_id} until status=completed.
In the photogrammetry API vs Tripo comparison: PixelAPI costs $4.495 per model (cost-plus, no subscription); Tripo3D costs $0.20–$0.30 per model at flat per-call rates. Tripo is cheaper per model, but PixelAPI offers more output formats (GLB, OBJ, FBX, USDZ, STL vs Tripo's GLB, OBJ, FBX, STL — USDZ is exclusive to PixelAPI), explicit PBR material modes, and an automatic credit refund if generation fails. PixelAPI also integrates your 3D pipeline with background removal, upscaling, and staging under a single account.
Five formats: GLB (default — real-time engines and AR Quick Look), OBJ (universal interchange), FBX (game engines, Autodesk suite), USDZ (Apple AR Quick Look, iOS Safari), and STL (3D printing). Pass format=glb|obj|fbx|usdz|stl in the request body. USDZ is not available through Tripo3D's API — it is unique to PixelAPI among the main image-to-3D providers.
$4.495 per 3D model (4,495 credits). This is cost-plus pricing that covers provider cost, 18% RCM tax, forex markup, processing overhead, and the auto-refund guarantee. A paid plan is required; free-trial credits do not apply to this endpoint. See pixelapi.dev/pricing for the full plan breakdown.
Approximately 3 minutes (180 seconds) for a typical product photo. The API returns "estimated_seconds": 180 at submission. The backend monitors the job for up to 20 minutes before the status endpoint takes over reconciliation, so a generation will not silently stall after a gateway restart.
PNG, JPG, and WebP. Upload as a multipart image field, or pass image_url (an https:// URL) or image_base64. Maximum file size: 10 MB. The shortest side must be at least 256 px. Images with a long side exceeding 2048 px are automatically resized — no need to downscale manually.
The image-to-3D endpoint requires a paid plan. New accounts receive 300 free credits for other PixelAPI tools (background removal, upscaling, and similar), but those trial credits do not unlock the 3D generation endpoint. Upgrade to any paid plan at pixelapi.dev/pricing to get started.
Four material modes: PBR (physically-based — default; generates albedo, roughness, metalness, and normal maps for game engines and AR), Shaded (pre-baked diffuse-only, smaller files), All (delivers both PBR and shaded outputs together), and None (geometry-only mesh, no texture maps). Pass material=PBR|Shaded|All|None.
Failed jobs are automatically detected and credits are refunded to your account. The status endpoint returns status=failed with an error_message; you are never charged for a generation that did not produce a downloadable file. The refund is applied atomically — no support ticket required.
Up to 2 concurrent 3D generation jobs per account at any time (all paid plans). Standard request-rate limits: 60 req/min on Starter, 120 on Pro, 300 on Scale. Failed submissions are not counted against the rate limit. For high-throughput batch processing, contact support@pixelapi.dev.
Yes. Models generated through the PixelAPI photogrammetry API are delivered as standard 3D files. Standard commercial use — product visualization, e-commerce AR, game assets, print-on-demand — is permitted. Review the PixelAPI Terms of Service for the full IP and licensing terms.
A single image is enough. The endpoint uses AI-based single-image 3D reconstruction — submit one product photo from any angle and receive a complete textured mesh. For the cleanest results, use a photo with the subject in focus against a neutral or removed background, and pass a brief prompt (up to 400 characters) to describe the object type and style — for example, "white ceramic mug, clean product photo, no background".