What the Tripo API is, how to get an API key, REST endpoints and documentation, pricing and credits, Python examples for text-to-3D and image-to-3D, and how to integrate it into your own app.
The Tripo 3D API is the developer-facing counterpart to Tripo Studio's browser workspace - a REST API that exposes the same underlying 3D generation engine (text-to-3D, image-to-3D, multi-view, texturing, rigging, and intelligent segmentation) as HTTP endpoints you call from your own code. Instead of a human clicking through a UI, your application submits a request, and Tripo's models do the generation work in the background.
It exists for exactly the situations a browser tool can't serve: generating assets on a schedule, letting your own product's users trigger 3D generation without ever seeing Tripo's interface, converting a product catalog into 3D/AR assets overnight, or wiring model generation into a game engine's editor tooling. If a human is going to look at and refine a model, Studio is the right tool; if a program needs to generate 3D content programmatically, that's what the API is for.
Important distinction: the Tripo API and a Tripo Studio subscription are separate products with separate billing. A Professional Studio plan does not grant API access, and API credits don't add generations to your Studio account - more on this in the pricing section below.
Every request to the API authenticates with an API key generated from your Tripo account's developer settings. Create a free account, navigate to the API/developer section, and generate a key - no separate signup process. Treat the key like a password:
# Store your key as an environment variable, never in source code
export TRIPO_API_KEY="your_api_key_here"
# Every request carries it 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"}'This page is an independent, educational guide - for the authoritative, up-to-date Tripo API documentation (exact endpoint signatures, current parameter names, and official rate limits), go to Tripo's own developer portal, linked from your account's API settings once you've signed in. Official docs are the source of truth for anything you're about to ship to production; treat this page as the conceptual map and the official reference as the legal text.
The Tripo REST API follows a consistent, simple pattern: JSON in, JSON out, over HTTPS, with every heavy operation modeled as an asynchronous task rather than a single blocking call. Generation takes seconds to a couple of minutes, so you submit a task, get an ID back immediately, and either poll for the result or receive a webhook when it's ready.
POST a task with your prompt or image and parameters
Response returns immediately with a task identifier
GET the task status, or register a webhook callback
On success, the response includes signed model URLs
Endpoint paths shown here are illustrative of the public API's documented structure - always confirm exact routes and parameters in the official reference before writing production code.
Unlike Studio's flat monthly plan, the Tripo API cost model is entirely usage-based: you top up a credit balance and each operation deducts a published amount - no monthly generation cap to hit, just a balance to monitor and refill. That structure makes forecasting refreshingly precise once you know your expected call 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 |
| Format conversion | Low / varies | Between GLB, FBX, OBJ, STL, USDZ, 3MF |
Budgeting formula: expected monthly generations × per-operation credits, plus a 20–30% buffer for retries and failed jobs. Confirm current per-operation pricing on Tripo's official API pricing page before finalizing a cost model - prices and promotions shift over time.
Both Studio and the API run on a credits system, but they are separate pools with separate billing - this is the single most common point of confusion for new developers. A Studio subscription (Basic/Professional/Advanced/Premium) deposits credits you spend generating through the browser workspace; API credits are purchased independently and consumed per call. Funding one does not fund the other.
| Studio credits | API credits | |
|---|---|---|
| Billing | Flat monthly/annual plan | Usage-based, top up as needed |
| Spent via | Browser workspace | HTTP calls from your code |
| Shared pool? | No - entirely separate | |
If you mainly generate by hand and only occasionally script something, Studio alone is enough - see our Studio pricing guide. If you're building a product on top of Tripo, budget the API separately.
Submit a text prompt as a text_to_model task and poll for the result - this is the most common starting point for API integrations.
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 cute chibi robot companion, rounded plastic shell",
"model_version": "v3.1"
}'Upload a reference image first, then submit an image_to_model task referencing the uploaded file. Clean background, even lighting, and a three-quarter angle produce the best results here, exactly as in Studio.
# 1. Upload the reference image
curl -X POST https://api.tripo3d.ai/v2/openapi/upload \
-H "Authorization: Bearer $TRIPO_API_KEY" \
-F "file=@product_photo.jpg"
# 2. Submit the image-to-model task with the returned file token
curl -X POST https://api.tripo3d.ai/v2/openapi/task \
-H "Authorization: Bearer $TRIPO_API_KEY" \
-H "Content-Type: application/json" \
-d '{"type": "image_to_model", "file_token": "returned_token_here"}'The API is plain REST/JSON, so any HTTP client works - requests is the simplest way to get started in Python. This mirrors the submit → poll → download pattern every integration builds on.
import requests, time, os
API_KEY = os.environ["TRIPO_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 registered in the task submission - cheaper on both ends and avoids accidentally tripping a rate limit with aggressive polling.
Putting text-to-3D, polling, and segmentation together - a realistic small pipeline: generate a model, then split it into parts.
def wait_for_task(task_id, headers, base):
while True:
r = requests.get(f"{base}/task/{task_id}", headers=headers).json()["data"]
if r["status"] == "success": return r["output"]
if r["status"] == "failed": raise RuntimeError("task failed")
time.sleep(3)
# Step 1: generate the base model
gen = requests.post(f"{BASE}/task", headers=headers, json={
"type": "text_to_model", "prompt": "a segmented toy robot"
}).json()["data"]["task_id"]
model_out = wait_for_task(gen, headers, BASE)
# Step 2: segment the completed model into parts
seg = requests.post(f"{BASE}/task", headers=headers, json={
"type": "segmentation", "original_model_task_id": gen, "level": "balanced"
}).json()["data"]["task_id"]
seg_out = wait_for_task(seg, headers, BASE)
print("Segmented parts ready:", seg_out)Simple, works everywhere, no public endpoint needed on your side. Higher latency and request count - fine for scripts and prototypes.
Register a callback URL; Tripo POSTs the result the moment it's ready. Near-zero latency, far fewer requests - the right choice for production volume.
Batch-convert product photography into 3D/AR assets overnight via scripted image-to-3D calls across a whole inventory.
Let your own app's users trigger 3D generation - a customization tool, a game's asset pipeline - without ever touching Tripo's UI.
Rate limits and concurrency caps typically scale with your API credit tier; implement exponential backoff on 429 responses and batch submissions at modest concurrency (start around 5–10 parallel tasks and measure). Exact numbers live in the official docs and can change - read response headers rather than hard-coding a limit.
Create a free account, generate a key from developer settings, and run the Python example above in a few minutes.
Get started free →