Evaluating a photogrammetry API vs CSM for your product pipeline? PixelAPI's image-to-3D API turns one product photo into a fully textured 3D model at $4.495 per model — cost-plus pricing, no monthly subscription, automatic credit refund if generation fails. POST one image to https://api.pixelapi.dev/v1/image-to-3d; receive GLB, OBJ, FBX, USDZ, or STL with PBR or Shaded materials in approximately 3 minutes. No monthly seat licence. No manual invoicing. CSM and PixelAPI both convert a photo to a mesh, but they differ on output format breadth, billing model, and production reliability guarantees.
Sign up, upgrade to any paid plan, and POST your product image. The endpoint returns a generation_id; poll GET /v1/image-to-3d/{generation_id} until status=completed, then download the model from output_url. Failed jobs are automatically refunded — you are never charged for a broken result.
# Submit (returns immediately with a generation_id)
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"
# {"generation_id":"uuid","status":"processing","estimated_seconds":180,...}
# Poll until completed (~3 minutes)
curl https://api.pixelapi.dev/v1/image-to-3d/UUID \
-H "Authorization: Bearer YOUR_API_KEY"
# {"status":"completed","output_url":"https://..."}
import requests, time
API_KEY = "YOUR_API_KEY"
BASE = "https://api.pixelapi.dev/v1/image-to-3d"
headers = {"Authorization": f"Bearer {API_KEY}"}
# Submit
with open("product.jpg", "rb") as f:
r = requests.post(BASE, headers=headers,
files={"image": f},
data={"format": "glb", "material": "PBR"})
gen_id = r.json()["generation_id"]
# Poll every 15 s until completed or failed
while True:
result = requests.get(f"{BASE}/{gen_id}", headers=headers).json()
if result["status"] == "completed":
model = requests.get(result["output_url"]).content
with open("product.glb", "wb") as f: f.write(model)
break
elif result["status"] == "failed":
print("Failed — credits refunded:", result.get("error_message"))
break
time.sleep(15)
const FormData = require('form-data');
const fetch = require('node-fetch');
const fs = require('fs');
const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.pixelapi.dev/v1/image-to-3d';
// Submit
const form = new FormData();
form.append('image', fs.createReadStream('product.jpg'));
form.append('format', 'glb');
form.append('material', 'PBR');
const sub = await fetch(BASE, {
method: 'POST',
headers: { Authorization: `Bearer ${API_KEY}`, ...form.getHeaders() },
body: form,
});
const { generation_id } = await sub.json();
// Poll
let result;
do {
await new Promise(res => setTimeout(res, 15000));
result = await fetch(`${BASE}/${generation_id}`, {
headers: { Authorization: `Bearer ${API_KEY}` },
}).then(r => r.json());
} while (result.status === 'processing');
// Download result.output_url → product.glb
<?php
$client = new \GuzzleHttp\Client();
$response = $client->post('https://api.pixelapi.dev/v1/image-to-3d', [
'headers' => ['Authorization' => 'Bearer YOUR_API_KEY'],
'multipart' => [
['name' => 'image', 'contents' => fopen('product.jpg', 'r')],
['name' => 'format', 'contents' => 'glb'],
['name' => 'material', 'contents' => 'PBR'],
],
]);
$job = json_decode($response->getBody(), true);
$gen_id = $job['generation_id'];
// Poll GET /v1/image-to-3d/{$gen_id} every 15s until status == completed
do {
sleep(15);
$r = $client->get("https://api.pixelapi.dev/v1/image-to-3d/{$gen_id}",
['headers' => ['Authorization' => 'Bearer YOUR_API_KEY']]);
$result = json_decode($r->getBody(), true);
} while ($result['status'] === 'processing');
file_put_contents('product.glb',
$client->get($result['output_url'])->getBody());
require 'faraday'
require 'faraday/multipart'
require 'json'
conn = Faraday.new('https://api.pixelapi.dev') do |f|
f.request :multipart
f.adapter Faraday.default_adapter
end
resp = conn.post('/v1/image-to-3d') do |req|
req.headers['Authorization'] = 'Bearer YOUR_API_KEY'
req.body = {
image: Faraday::Multipart::FilePart.new('product.jpg', 'image/jpeg'),
format: 'glb',
material: 'PBR',
}
end
gen_id = JSON.parse(resp.body)['generation_id']
# Poll
loop do
sleep 15
r = JSON.parse(conn.get("/v1/image-to-3d/#{gen_id}") { |req|
req.headers['Authorization'] = 'Bearer YOUR_API_KEY'
}.body)
break File.binwrite('product.glb', Faraday.get(r['output_url']).body) if r['status'] == 'completed'
break puts("Failed: #{r['error_message']}") if r['status'] == 'failed'
end
package main
import (
"bytes"; "fmt"; "io"; "mime/multipart"; "net/http"; "os"; "time"
)
func main() {
var buf bytes.Buffer
w := multipart.NewWriter(&buf)
f, _ := os.Open("product.jpg")
defer f.Close()
part, _ := w.CreateFormFile("image", "product.jpg")
io.Copy(part, f)
w.WriteField("format", "glb")
w.WriteField("material", "PBR")
w.Close()
req, _ := http.NewRequest("POST",
"https://api.pixelapi.dev/v1/image-to-3d", &buf)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", w.FormDataContentType())
resp, _ := (&http.Client{}).Do(req)
defer resp.Body.Close()
// parse generation_id from JSON response, then poll
// GET /v1/image-to-3d/{generation_id} every 15s
fmt.Println("Submitted — poll GET /v1/image-to-3d/{generation_id}")
_ = time.Second // silence import
}
The table below compares PixelAPI's image-to-3D API against CSM and other mainstream competitors. PixelAPI uses cost-plus pricing that covers provider, processing, taxes, and the auto-refund guarantee. Meshy and Rodin use subscription-pooled credits; Tripo3D is flat per-call; CSM is freemium (see csm.ai/pricing for current rates).
| Provider | Free tier | Per-model cost | Output formats | Auto-refund on failure |
|---|---|---|---|---|
| PixelAPI | None for 3D (300 free credits for other tools) | $4.495 | GLB · OBJ · FBX · USDZ · STL | ✓ Automatic |
| CSM.ai | See csm.ai/pricing | See csm.ai/pricing | GLB · OBJ | Not documented |
| Meshy | 100 credits/mo | $0.40 (mesh) · $0.60 (2K textures) | GLB · FBX · USDZ · OBJ | Not documented |
| Rodin (fal.ai) | None on API | $0.40 (base) · $1.20 (HighPack 4K) | GLB · OBJ · FBX | Not documented |
| Tripo3D | None on API | $0.20 (no texture) · $0.30 (standard texture) | GLB · OBJ · FBX · STL | Not documented |
Pricing verified from each rival's public pricing page, November 2026. CSM.ai: site unreachable during verification — see csm.ai/pricing. Meshy: docs.meshy.ai/en/api/pricing (20–30 credits/model; Pro plan 1,000 credits for $20). Rodin: fal.ai/models/fal-ai/hyper3d/rodin ($0.40/generation). Tripo3D: developers.tripo3d.ai ($0.20 no-texture, $0.30 standard texture). PixelAPI cost-plus pricing reflects provider cost, 18% RCM tax, forex, overhead, and 30% margin; failed jobs are automatically refunded.
Each successful call to POST /v1/image-to-3d returns a standard 3D model file you can open in any 3D tool or drop straight into an AR or game-engine pipeline.
Binary glTF bundles geometry, textures, and materials into one file. Supported by Shopify 3D, BigCommerce, Sketchfab, model-viewer, and every major game engine. Pass format=glb (default).
Widely accepted by Blender, Maya, 3ds Max, Cinema 4D, and legacy toolchains. Useful when you need a simple mesh for further editing. Pass format=obj.
Natively importable into Unity, Unreal Engine, and the full Autodesk suite. FBX with PBR materials ships a production-ready asset for indie and AA studios. Pass format=fbx.
Apple's preferred format for AR Quick Look on iOS and macOS. Drop the USDZ link into a Shopify product page and shoppers can view the product in their room before buying. Pass format=usdz.
The standard exchange format for 3D printing and CNC machining. Use STL to send a generated asset straight to a print shop or prototype service. Pass format=stl.
Pass material=PBR (default) for physically-based rendering, Shaded for unlit baked colour, All for both, or None for a clean mesh without embedded materials.
The endpoint accepts PNG, JPG, and WebP images in three ways:
imageimage_url in the JSON body (must be an https:// URL)image_base64 in the JSON bodyConstraints: maximum 10 MB per file; shortest side must be at least 256 px. Images with a long side larger than 2,048 px are automatically downsampled before submission — your original file is not modified. RGBA PNG input (transparent backgrounds from a prior background-removal step) is preserved to help the mesh generation produce a cleaner cutout.
An optional prompt field (up to 400 characters) can hint at the object type or desired output style.
The image-to-3D API fits into these production pipelines. Each links to a 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 Engine. Rapid concept-to-asset pipeline for indie and AA studios.
Batch-process product SKUs overnight. Async polling and auto-refund on failure all built in — no babysitting required.
Combine background removal + image-to-3D 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.
Trigger 3D generation on product upload via webhook and attach the GLB to the product's 3D model field automatically.
No-code workflow: watch a Google Drive folder, generate GLBs, save back to Drive or push to Shopify.
Magento 2 observer pattern for automated 3D model generation on catalog product save events.
Server-side API route that accepts product images and returns a 3D model URL for model-viewer or Three.js.
BigCommerce script that auto-uploads GLB files to product media when photos are updated.
Code injection + serverless proxy to surface 3D model viewers on Squarespace Commerce product pages.
CSM (now part of Google) offers GLB and OBJ. PixelAPI adds FBX, USDZ, and STL and keeps billing under one account with your existing image pipeline.
Meshy is cheaper per model ($0.40–$0.60) on a subscription. PixelAPI is strict pay-per-use — better for irregular 3D needs with no monthly commitment.
Rodin's base tier ($0.40) is cheaper; the HighPack 4K tier ($1.20) is comparable. PixelAPI adds USDZ and STL and runs alongside your image tools on one account.
Tripo3D ($0.20–$0.30) is the most affordable. PixelAPI's five output formats (vs four) and automatic failure refund suit production pipelines where reliability matters.
Photogrammetry API vs Tripo · i23d API vs Rodin
Up to 2 concurrent image-to-3D jobs per account at any time (all plans). A third submission while two are in flight returns HTTP 429 with code: "too_many_inflight" — no credits are charged. Standard API rate limits: 60 req/min on Starter, 120 on Pro, 300 on Scale. For high-throughput batch processing, contact support@pixelapi.dev.
Recommended error-handling pattern: exponential backoff starting at 15 s on 429, doubling up to 120 s. If a job has not reached completed or failed status within 20 minutes, the status endpoint automatically reconciles the job against the provider — it will not silently stall. All failed jobs are refunded automatically; credits appear in your dashboard immediately after the refund is applied.
# Python — polling with backoff and failure guard
import requests, time
BASE = "https://api.pixelapi.dev/v1/image-to-3d"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
r = requests.post(BASE, headers=headers,
files={"image": open("product.jpg", "rb")},
data={"format": "glb"})
r.raise_for_status()
gen_id = r.json()["generation_id"]
for attempt in range(80): # 80 × 15 s = 20 min ceiling
time.sleep(15)
result = requests.get(f"{BASE}/{gen_id}", headers=headers).json()
if result["status"] == "completed":
print("Done:", result["output_url"]); break
if result["status"] == "failed":
print("Refunded:", result.get("error_message")); break
else:
print("Timed out — check dashboard")
It compares PixelAPI's image-to-3D REST API against CSM.ai for teams building hosted, pay-per-call pipelines. Key differences: PixelAPI returns five formats (GLB, OBJ, FBX, USDZ, STL), supports PBR and Shaded materials, bills at $4.495 per model with no monthly fee, and auto-refunds credits when generation fails.
It is the endpoint at POST /v1/image-to-3d. Submit one product or object photo; receive a fully textured 3D model in GLB, OBJ, FBX, USDZ, or STL with PBR or Shaded materials. The generation is asynchronous — poll GET /v1/image-to-3d/{generation_id} until status=completed. Failed jobs are automatically refunded.
CSM (Common Sense Machines, now part of Google) generates 3D models primarily in GLB and OBJ. PixelAPI adds FBX, USDZ, and STL to that list and bills strictly pay-per-call — no seat licences or monthly minimums. PixelAPI also documents and guarantees automatic credit refunds for failed jobs, and keeps all image operations under one API key and billing account.
Five: GLB (default), OBJ, FBX, USDZ, and STL. Pass format=glb|obj|fbx|usdz|stl. Material options are PBR (default), Shaded, All (both), or None (mesh only). Pass material=PBR|Shaded|All|None.
$4.495 per 3D model (4,495 credits at $0.001/credit on the Starter plan). This is cost-plus pricing that covers the provider bill, 18% RCM tax, forex, overhead, and a 30% margin — not a cheapest-rival race. A paid plan is required. See pixelapi.dev/pricing for the full plan breakdown.
Approximately 3 minutes (the API returns estimated_seconds: 180 at submission). The backend monitors the job for up to 20 minutes; if the gateway restarts mid-job, the status endpoint reconciles automatically so the job does not silently stall.
PNG, JPG, and WebP, up to 10 MB. The shortest side must be at least 256 px. Images with a long side larger than 2,048 px are automatically resized. Submit as a multipart image field, or as image_url (https:// URL) or image_base64 in a JSON body.
The image-to-3D endpoint requires a paid plan. New accounts receive 300 free credits for other PixelAPI tools (background removal, upscaling, staging, and similar), but those trial credits do not unlock the 3D generation endpoint. Upgrade to any paid plan at pixelapi.dev/pricing.
Up to 2 concurrent image-to-3D jobs per account at any time (all plans). A third submission returns HTTP 429 with code: "too_many_inflight" — no credits are charged. For high-throughput batch work, contact support@pixelapi.dev.
If generation fails at any stage — provider error, download failure, or quality rejection — the full 4,495 credits are automatically refunded to your account in a single atomic database transaction. The refund is visible in your dashboard immediately. You are never charged for a broken result.