REST API · Live

Photogrammetry API vs CSM: Image-to-3D API Comparison

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.

5 output formats PBR materials $4.495 / model Auto-refund on failure No subscription Paid plan required
Get an API key Quick start See pricing API docs

Quick start — one photo in, 3D model out

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
}

Photogrammetry API vs CSM: Pricing Comparison

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.

What you get back

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.

GLB — the universal default

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).

OBJ — interchange standard

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.

FBX — game engines

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.

USDZ — iOS AR Quick Look

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.

STL — 3D printing

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.

Material control

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.

Input options and size limits

The endpoint accepts PNG, JPG, and WebP images in three ways:

Constraints: 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.

Common workflows

The image-to-3D API fits into these production pipelines. Each links to a setup guide:

Product 3D for e-commerce

Turn catalog photos into embeddable 3D viewers. GLB output drops straight into Shopify, BigCommerce, and WooCommerce product pages.

E-commerce AR

USDZ output powers iOS AR Quick Look — shoppers preview furniture, shoes, and electronics in their room before buying.

Game development

FBX output with PBR materials imports directly into Unity and Unreal Engine. Rapid concept-to-asset pipeline for indie and AA studios.

Batch 3D model generation

Batch-process product SKUs overnight. Async polling and auto-refund on failure all built in — no babysitting required.

AR visualisation

Combine background removal + image-to-3D in one API account for clean isolated product shots and their AR counterparts.

E-commerce 3D catalogues

Scale 3D catalog production. Upload a product photo, receive a GLB; no 3D artist required for base meshes.

Integrations

Shopify

Trigger 3D generation on product upload via webhook and attach the GLB to the product's 3D model field automatically.

Make.com

No-code workflow: watch a Google Drive folder, generate GLBs, save back to Drive or push to Shopify.

Magento / Adobe Commerce

Magento 2 observer pattern for automated 3D model generation on catalog product save events.

Next.js

Server-side API route that accepts product images and returns a 3D model URL for model-viewer or Three.js.

BigCommerce

BigCommerce script that auto-uploads GLB files to product media when photos are updated.

Squarespace

Code injection + serverless proxy to surface 3D model viewers on Squarespace Commerce product pages.

Comparison vs alternatives

vs CSM.ai

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.

vs Meshy

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.

vs Rodin (Hyper3D)

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.

vs Tripo3D

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

Rate limits & error handling

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")

Frequently asked questions

What is the photogrammetry API vs CSM comparison about?

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.

What is PixelAPI's image-to-3D API (i23d API)?

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.

How does PixelAPI's photogrammetry API compare to CSM?

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.

What output formats does the photogrammetry API support?

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.

How much does the PixelAPI photogrammetry API cost?

$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.

How long does image-to-3D generation take?

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.

What image formats and sizes are accepted?

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.

Is there a free trial for the photogrammetry API?

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.

What is the concurrent job limit?

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.

How do failed jobs get refunded?

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.

Get an API key Read full API docs Compare all plans