Photogrammetry API vs Tripo3D

A production REST API that converts a single photo into a textured 3D model (GLB or OBJ) via one HTTP call. No subscription, no 3D software, no local rendering. $0.01 per model — half the price of Meshy and a fraction of what Tripo3D costs on a subscription plan. 500 free credits, no credit card.

Why use a photogrammetry API instead of Tripo3D?

Tripo3D, Meshy, and Rodin all offer compelling 3D generation tools — but they're primarily subscription-based consumer platforms. When you need to generate 3D models programmatically at scale (e-commerce product listings, game asset pipelines, AR catalog apps), a pure REST API with pay-as-you-go pricing and no monthly lock-in is the better architecture. PixelAPI's image-to-3D endpoint gives you:

• No subscription required. Pay $0.01 per model. Stop when you want. Scale instantly.
• Standard REST + polling pattern. POST the image, get a job ID, poll until complete. Integrates into any backend in under 20 lines of code.
• Auto-refund on failure. If a generation fails, credits are returned to your balance automatically. You never pay for broken results.
• SDK support. Python, Node.js, PHP, Ruby, Go — all handle auth, polling, and retry logic out of the box.

Quick start — image to 3D in one API call

Sign up, copy your key from the dashboard, and POST your image. The endpoint returns a generation_id; poll until status=completed, then download the GLB from output_url.

# Step 1: Submit the image
curl -X POST https://api.pixelapi.dev/v1/3d/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "[email protected]" \
  -F "format=glb" \
  -F "texture_size=1024"
# Response: {"id": "uuid", "status": "queued", "credits_used": 10, ...}

# Step 2: Poll for completion
curl https://api.pixelapi.dev/v1/3d/status/UUID \
  -H "Authorization: Bearer YOUR_API_KEY"
# Response: {"status": "completed", "output_url": "https://...", "files": {...}}

pip install pixelapi
---
import time
from pixelapi import PixelAPI

client = PixelAPI(api_key="YOUR_API_KEY")

# Submit image-to-3D job
job = client.generate_3d(
    image="product.jpg",
    format="glb",           # "glb", "obj", or "all"
    texture_size=1024       # 512, 1024, or 2048
)

# Poll until done (SDK handles polling automatically)
result = client.wait_for_3d(job["id"])
print(result["output_url"])  # download GLB from here

npm install pixelapi
---
import { PixelAPI } from "pixelapi";

const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });

const job = await client.generate3d({
  image: "./product.jpg",
  format: "glb",        // "glb", "obj", or "all"
  textureSize: 1024,    // 512, 1024, or 2048
});

// SDK auto-polls until completed
const result = await client.waitFor3d(job.id);
console.log(result.outputUrl); // download GLB

composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;

$client = new Client(getenv("PIXELAPI_KEY"));
$job = $client->generate3d([
    "image"        => "product.jpg",
    "format"       => "glb",
    "texture_size" => 1024,
]);

// Poll manually
do {
    sleep(3);
    $status = $client->get3dStatus($job["id"]);
} while ($status["status"] === "queued" || $status["status"] === "processing");

echo $status["output_url"];

gem install pixelapi
---
require "pixelapi"

client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
job = client.generate_3d(
  image: "product.jpg",
  format: "glb",
  texture_size: 1024
)

result = client.wait_for_3d(job["id"])
puts result["output_url"]

go get github.com/pixelapi/pixelapi-go
---
import "github.com/pixelapi/pixelapi-go"

client := pixelapi.New("YOUR_API_KEY")
job, err := client.Generate3D("product.jpg", pixelapi.ThreeDOptions{
    Format:      "glb",
    TextureSize: 1024,
})
if err != nil { panic(err) }

result, err := client.WaitFor3D(job.ID)
if err != nil { panic(err) }
fmt.Println(result.OutputURL)

Pricing — photogrammetry API vs Tripo3D vs Meshy vs Rodin

PixelAPI's per-model price is set at exactly half the cheapest mainstream rival. No subscription, no monthly commitment.

Pricing verified from each rival's public pricing page May 2026. PixelAPI's per-model price is set at exactly half the cheapest mainstream API rival per our pricing principle.

What you get back

How the async job system works

3D generation is compute-intensive and takes 30–60 seconds. The endpoint is intentionally asynchronous to avoid HTTP timeout issues in serverless and mobile clients:

1. POST your image to /v1/3d/generate → receive generation_id and status=queued immediately.
2. Poll GET /v1/3d/status/{generation_id} every 2–5 seconds until status=completed or status=failed.
3. Download the 3D model from output_url (GLB) or from the files dict (GLB + OBJ URLs) in the completed response.

The Python and Node SDKs provide a wait_for_3d() / waitFor3d() helper that handles the polling loop and exponential backoff automatically.

Common workflows

The image-to-3D API is the foundation for these production workflows. Each links to a setup guide:

More 3D use-case guides: all industries →

Integrations & SDKs

Comparison vs alternatives

Rate limits & error handling

Default 60 requests/minute on the free tier, 600 on paid tiers. Exceeding the limit returns HTTP 429 with a Retry-After header. Use exponential backoff starting at 2 seconds. The Python and Node SDKs handle this automatically.

Generation timeouts return HTTP 504 and credits are refunded. Failed jobs (status=failed) also trigger automatic credit refunds — you never pay for an incomplete result.

# Python: auto-retry on 429, auto-refund on failure
from pixelapi import PixelAPI
client = PixelAPI(api_key="...", max_retries=4)

job = client.generate_3d(image="product.jpg", format="glb")
result = client.wait_for_3d(job["id"])  # auto-polls, auto-retries

if result["status"] == "completed":
    print(result["output_url"])
elif result["status"] == "failed":
    print("Job failed — credits automatically refunded")

Frequently asked questions