Everything to wire AI 3D generation into your own app: auth, the async task flow, every operation's credit cost, code examples, and how API billing differs from a Studio subscription.
The Tripo API exposes the same generation engine behind Tripo Studio - text-to-3D, image-to-3D, multi-view input, texturing, rigging, and intelligent segmentation - as a set of HTTP endpoints you call from your own code. It's built for exactly the use cases a browser tool can't serve: generating 3D assets on a schedule, letting your app's users trigger generation without touching Tripo's UI, batch-processing a product catalog overnight, or wiring 3D creation into a game engine's editor tooling. If you're a human clicking buttons, you want Studio; if you're a program calling functions, you want the API - and importantly, they are separate products with separate billing, which trips up more developers than any technical detail here.
Standard REST over HTTPS, JSON in and out, API-key authentication - no SDK required, though community wrappers exist for popular languages.
Generation takes seconds to minutes, so every heavy operation is a submit-then-poll (or submit-then-webhook) task, not a single blocking request.
Base generation, texturing, segmentation, rigging, and format conversion are all separately callable - build exactly the pipeline stage you need.
You buy or are allocated API credits and each call deducts a published amount - no monthly generation cap to hit, just a balance to top up.
Generate an API key from your Tripo account's developer settings, then pass it as a bearer token on every request. Keep it server-side - never ship it inside a client app or public repo, since anyone holding it can spend your credit balance.
# Every request carries your key as a Bearer token
curl -X POST https://api.tripo3d.ai/v2/openapi/task \
-H "Authorization: Bearer $TRIPO_API_KEY" \
-H "Content-Type: application/json" \
-d '{"type": "text_to_model", "prompt": "a weathered stone lantern"}'Every generation follows the same four-stage pattern, whether it's a base model, a texture pass, or a segmentation job.
Why async matters for your architecture: never block a user-facing request thread on a generation call. Submit the task, return immediately with a "processing" state to your frontend, and either poll from a background worker or let a webhook update your database when the model's ready.
The API is organized around task types - each pipeline stage is its own callable operation.
Endpoint paths and exact parameter names shown here are illustrative of the public API's structure - always work from Tripo's current official reference for production integration.
Unlike Studio's flat monthly-plan model, the API bills every operation individually against a credit balance you top up - so cost is a direct function of what you call, which makes forecasting refreshingly precise once you know your expected volume.
| Operation | Approx. credits | Notes |
|---|---|---|
| Base generation (text/image → model) | ~20 | v3.0/v3.1 base mesh, standard detail |
| + High-detail geometry | +~30 | Added resolution pass on top of base |
| + Quad remesh | +~7.5 | Animation-friendly topology conversion |
| Re-texturing | 20–50 | Varies with resolution / HD option |
| Intelligent segmentation | ~80 | Part-splitting with mesh completion |
| Smart Mesh (P1) generation | 60–80 | Depends on text vs. image input |
| Auto-rigging | Varies | Skeleton + skin weights on a completed model |
| Format conversion | Low / varies | Between GLB, FBX, OBJ, STL, USDZ, 3MF |
Budget formula: expected monthly generations × per-operation credits, plus a 20–30% buffer for retries and failed jobs - the same iterate-cheap-then-commit discipline that applies in Studio applies here, just automated. Confirm current per-operation pricing on Tripo's official API pricing page before finalizing a cost model.
Submit a text-to-model task, poll until it completes, then download the result. This is the pattern every higher-level integration builds on.
import requests, time
API_KEY = "your_api_key"
BASE = "https://api.tripo3d.ai/v2/openapi"
headers = {"Authorization": f"Bearer {API_KEY}"}
# 1. Submit a text-to-model task
resp = requests.post(f"{BASE}/task", headers=headers, json={
"type": "text_to_model",
"prompt": "a weathered stone lantern, moss-covered base",
"model_version": "v3.1"
})
task_id = resp.json()["data"]["task_id"]
# 2. Poll until the task completes
while True:
status = requests.get(f"{BASE}/task/{task_id}", headers=headers).json()
state = status["data"]["status"]
if state == "success":
model_url = status["data"]["output"]["model"]
break
elif state == "failed":
raise RuntimeError("Generation failed")
time.sleep(3)
# 3. Download the finished model
model_data = requests.get(model_url).content
with open("lantern.glb", "wb") as f:
f.write(model_data)
print(f"Saved lantern.glb - task {task_id} complete")Production tip: replace the polling loop with a webhook callback URL in the task submission - it's cheaper on both ends and avoids the classic mistake of polling too aggressively and tripping a rate limit.
Simple to implement, works everywhere, no public endpoint needed on your side. Costs more requests, adds latency (you find out on your next poll, not the instant it finishes), and needs backoff logic to avoid hammering the API.
Register a callback URL when submitting a task; Tripo POSTs the result to you the moment it's ready. Near-zero latency and far fewer requests - the right choice for any production pipeline processing real volume.
Batch pipelines (catalog conversion, nightly asset generation) should default to webhooks; quick scripts and prototypes can get away with a simple poll loop.
Like any production API, expect per-minute request caps and a limit on how many generation tasks can run concurrently under your key - both typically scale with your API credit tier or plan level. Practical guidance: batch submissions with modest concurrency (start around 5–10 parallel tasks and measure), implement exponential backoff on 429 responses, and cache/reuse results rather than regenerating identical requests. Exact numbers are published in Tripo's official API documentation and can change - build your retry logic to read the response headers rather than hard-coding a limit.
This is the single most common point of confusion for new developers, so it deserves its own section: a Tripo Studio subscription (Basic/Professional/Advanced/Premium) and the Tripo API are billed completely separately. Your $19.9/month Professional plan credits live in Studio and are spent when you generate through the browser workspace - they do not fund API calls, and API credit purchases do not add generations to your Studio account. If you're building a product that needs both a team using Studio and a backend calling the API, budget for two separate line items, not one shared pool.
| Studio subscription | API | |
|---|---|---|
| Billing | Flat monthly/annual plan | Usage-based, top up as needed |
| Interface | Browser workspace | HTTP endpoints, your own code |
| Best for | Individual creators, teams working by hand | Apps, pipelines, automation, integrations |
| Credits shared? | No - entirely separate pools | |
If you mainly generate by hand and only occasionally script something, Studio alone is enough - see our Studio pricing guide. If you're building on top of Tripo, budget the API separately, and start with a free Studio account → to get API access provisioned.
Create a free account, generate an API key from developer settings, and run the example above in a few minutes.
Get started free →