Tripo 3d

Tripo 3D asset generation

Tripo (product of VAST AI Research; consumer brand "Tripo AI") turns text, single images, and multi-view

image sets into textured 3D meshes, then post-processes them into engine-ready assets: PBR texturing,

retopology, auto-rigging, preset animation, and format conversion. It ships as a web Studio, mobile apps,

and an async task-based REST API ("Tripo OpenAPI"). This skill is about producing production-usable

assets through that API and Studio.

> Evidence labels used below: [Doc] = official Tripo documentation/SDK; [1P] = first-party

> Tripo blog/marketing claim (directional, not independently verified); [3P] = disclosed third-party

> source; [Heuristic] = production judgment, not a documented guarantee. Volatile facts carry a

> verified 2026-07-10 date; re-check them, because Tripo ships model and pricing changes frequently.

When to use Tripo, and when not to

Tripo's strength is speed and coverage: a usable single-object mesh in tens of seconds to a couple of

minutes, across a huge range of props, characters, and hard-surface objects, with texturing/rigging/format

export in one API. [Heuristic] Reach for it when you need many game/AR/previz/3D-print assets fast, when

you have a concept image or clean reference, or when you want a first-pass base mesh to refine by hand.

Do not rely on Tripo (or set expectations accordingly) for:

• Clean production topology out of the box. Raw generation output is typically dense, organic

triangulation. Use quad remesh, smart low-poly, or retopo in a DCC tool before deforming/subdividing.

[Heuristic]

• Full scenes / multi-object layouts. It generates one object per task. Compose scenes yourself.
• Precise dimensional/CAD accuracy. It is a generative reconstruction, not a measured model. For

3D printing, verify scale, wall thickness, and manifold-ness.

• Guaranteed likeness of real, identifiable people, or reproduction of copyrighted/branded characters.

Treat these as rights risks (see Rights & licensing).

• Text, fine logos, thin lattices, transparent/refractive materials. These are common failure classes.

[Heuristic]

The task model (how the API actually works) — [Doc], verified 2026-07-10

Everything is an asynchronous task. You submit a task, receive a task_id, then poll (or receive a

webhook) until it succeeds, then read output URLs.

• Base URL: https://api.tripo3d.ai/v2/openapi
• Auth: header Authorization: Bearer YOUR_API_KEY. Create keys at platform.tripo3d.ai/api-keys.
• Create a task: POST /v2/openapi/task with a JSON body whose type selects the operation.
• Poll a task: GET /v2/openapi/task/{task_id}. Response carries status, progress, output

(download URLs), and consumed_credit (exact credits charged for that task).

• Status values: queued → running → success (also failed, cancelled, banned, expired,

unknown). Poll until terminal; read model URLs from output on success.

• Uploads: input images may be passed as a url (public JPEG/PNG, max 20 MB), a file_token from

direct upload, or an object from STS upload (bucket: "tripo-data", key: <resource_uri>). STS upload

is Tripo's recommended path. Output download URLs are time-limited — fetch and store them promptly.

• Chaining: post-process tasks reference a prior task by id

(original_model_task_id / draft_model_task_id), so a model → texture → rig → convert pipeline is a

chain of tasks, not a re-upload each time.

[Heuristic] Poll with backoff (e.g., 2 s, then 3–5 s) rather than tight loops; generation is

seconds-to-minutes depending on model/options. For batch/production, prefer webhooks if your integration

path supports them (native webhook support varies by API surface and by proxy providers such as fal/Runware,

which expose an X-Webhook-URL-style header [3P], verified 2026-07-10; confirm against current Tripo docs

before depending on it, otherwise poll).

Model versions — [Doc]/[1P], verified 2026-07-10

Select with model_version on generation tasks. Volatile — re-check the changelog.

| Family | API model_version / selector | Character | Face/poly envelope |

|---|---|---|---|

| v3.0 (HD / "H3") | v3.0-20250812 | Stable, general default | up to ~1M–1.5M tris [Doc] |

| v3.1 (HD / "H3.1") | v3.1-20260211 | Higher geometric density, sharper edges, stronger PBR | up to ~1.5M–2M tris [Doc] |

| P1 (Smart Mesh P1.0) | p1 selector (premium tier) | Native 3D-diffusion, game-ready low-poly, orientation control, seeds; very fast | ~48–20,000 faces [Doc/1P] |

• v3.0 — safe general-purpose default when you want maximum detail and will retopo later. [Heuristic]
• v3.1 — pick for "hero" detail: denser geometry and better PBR response; costs more compute/time.

Marketed for hero game assets, cinematics, product shots. [1P]

• P1 — pick when you want engine-ready, controllable low-poly directly: a target face budget

(face_limit 48–20,000) and orientation control (default or align_image) so the asset faces a

predictable axis. Announced at GDC 2026 as a native-3D-diffusion architecture producing low-poly assets in

seconds. [1P] Costs more credits than v3.x per task. Older Turbo-v1.0, v1.4, and H2 versions also

exist for legacy/cheaper paths. [Doc]

The marketing "Hxx" names and the API model_version strings are not identical spellings — always drive the

API off the exact model_version string from the current docs, not the blog name.

Generation tasks and their parameters — [Doc], verified 2026-07-10

text_to_model

• type: "text_to_model", model_version, prompt (≤ 1024 chars; multilingual; no emoji/exotic Unicode).
• Optional: negative_prompt (≤ 255), image_seed, model_seed, texture_seed, style.

image_to_model

• type: "image_to_model", model_version, and a file (via file_token | url | object).
• enable_image_autofix cleans up the input; texture_alignment and orientation control how texture and

the asset's facing follow the image.

multiview_to_model

• type: "multiview_to_model", files = an ordered list [front, left, back, right].
• Front is required; other views may be omitted (pass empty for that slot). Use at least 2 views.

More consistent views → better back/side reconstruction. [Doc]

Shared generation controls

• texture (bool, default true; ~10 credits cheaper when false for geometry-only).
• pbr (bool, default true) — emit PBR maps (base color / metallic-roughness / normal) for lit pipelines.
• texture_quality: "standard" (default) or "detailed" (+10 credits).
• geometry_quality: "standard" or "detailed" (+20 credits) on supported versions.
• face_limit (int) — cap output triangles; the practical lever for engine budgets.
• quad (bool, default false, +5 credits) — quad-dominant remesh for cleaner edge flow / subdivision.
• smart_low_poly (bool, default false, +10 credits) — automatic low-poly-ization at generation time.
• auto_size (bool) — normalize real-world scale; compress for smaller GLB; export_uv; generate_parts

(+20 credits) to split into named parts; style for stylized geometry presets.

Post-processing pipeline — [Doc], verified 2026-07-10

Each references a prior task id, so you refine without re-generating:

• texture_model — re-texture an existing mesh. Key inputs: original_model_task_id, texture, pbr,

texture_quality, texture_alignment, texture_seed, part_names, bake, plus a text_prompt,

image_prompt, or style_image to redirect the look.

• refine_model — refine a draft mesh (draft_model_task_id).
• mesh_segmentation (40 cr) / mesh_completion (50 cr) — split into parts / fill holes and finish

partial geometry.

• smart_lowpoly (30 cr) — retopo high-poly → low-poly with face_limit, quad, bake, part_names.
• stylize_model — apply a stylization style: LEGO, VOXEL, VORONOI, MINECRAFT, with block_size.

Rigging & animation — [Doc], verified 2026-07-10

• check_riggable (type: "check_riggable", free) — validate a mesh can be auto-rigged before paying

to rig. Always gate on this for characters.

• rig_model (25 cr) — auto-rig. Params: original_model_task_id, out_format ("glb" | "fbx"),

rig_type, spec (skeleton spec, e.g. humanoid). Auto-rigging expects a roughly upright,

symmetric, single-character mesh with clearly separated limbs. [Heuristic]

• retarget_animation (10 cr per animation) — apply preset motions to the rigged mesh.

animation takes one or a list of "preset:<name>" values: preset:idle, preset:walk, preset:run,

preset:jump, preset:climb, preset:dive, preset:fall, preset:turn, preset:slash,

preset:shoot, preset:hurt, plus quadruped/hexapod/octopod/serpentine/aquatic variants for non-humanoids.

out_format, bake_animation, and export_with_geometry control the exported clip.

Format conversion / export — [Doc], verified 2026-07-10

• convert_model — original_model_task_id + format ∈ GLTF, USDZ, FBX, OBJ, STL, 3MF

(base 5 cr, +5 with extra options). Native generation output is GLB; convert to your target.

• Engine/tool mapping [Heuristic]: Unity/Unreal → FBX or glTF/GLB; Blender → GLB/glTF or

FBX; USD pipelines / Apple AR Quick Look → USDZ; 3D printing → STL or 3MF (STL drops

color; 3MF keeps color/material).

Prompt and input-image strategy — [Heuristic] unless marked

Text-to-3D prompts describe an *object*, not a scene: subject + form + material + style. Be concrete

about silhouette and material ("a low-poly stylized wooden treasure chest with iron bands, closed lid").

Use negative_prompt to suppress recurring artifacts ("extra limbs, floating parts, text"). Text-to-3D has

inherent ambiguity about unseen sides; expect to iterate on model_seed/image_seed.

Image-to-3D / multiview beats text for fidelity and control. For the best single-image result:

• Clean, centered subject on a plain/transparent background; fills most of the frame.
• Even, neutral lighting; avoid hard shadows/specular blowout that the model bakes into geometry/texture.
• A roughly 3/4 "hero" angle reads volume better than a flat orthographic front for single-image input.
• Set orientation/texture_alignment so the generated asset faces and textures consistently with the image.

Multiview is the highest-control path: supply consistent front/left/back/right renders of the *same*

object (same lighting, same scale). It resolves the "hallucinated back" problem that plagues single-image and

text input. Front is mandatory; add as many real views as you have.

Iteration and repair workflow — [Heuristic]

• Cheap first pass: generate at texture:false (geometry only) or a lower tier to judge form before

paying for texture. Lock the silhouette, then re-texture the winning geometry with texture_model

rather than regenerating.

• Vary seeds, not prompts, first. If geometry is 80% right, re-roll model_seed a few times before

rewriting the prompt.

• Move up the model ladder deliberately: v3.0 → v3.1 for detail; use P1 when you specifically need a

controlled low-poly/oriented game asset. Don't pay for v3.1 detail you'll immediately decimate.

• Fix, don't regenerate: holes → mesh_completion; too dense → smart_lowpoly/quad; wrong parts

granularity → mesh_segmentation; bad texture only → texture_model.

• Gate rigging: run check_riggable before rig_model; if it fails, the mesh usually needs a

cleaner, upright, limb-separated topology first.

Reviewing generated mesh quality — [Heuristic]

Before shipping a Tripo asset, check:

• Poly count vs. budget — did face_limit land where you need it? Overshoot → smart_lowpoly.
• Topology — raw output is triangulated and often uneven; if the asset will deform (rigged) or subdivide,

demand quad remesh/retopo. Straight-to-static-prop tolerates raw triangulation.

• Watertight / manifold — required for 3D printing; check for holes, non-manifold edges, flipped normals.
• UVs & texture — seams, stretching, baked-in lighting, low-res detail on text/logos. PBR maps present if

pbr:true. Re-texture if the geometry is good but the surface is not.

• Scale & pivot/orientation — confirm real-world size (auto_size) and that the pivot/facing matches your

engine's convention (P1 orientation helps here).

• Symmetry & floaters — check for asymmetry, detached fragments, fused parts (use generate_parts /

segmentation to separate).

Credits, cost, and rate limits — [Doc]/[3P], verified 2026-07-10

Billing is in credits: $1.00 = 100 credits. New accounts get 300 free credits, valid ~2 weeks.

Each task response reports exact consumed_credit. Representative task prices [Doc] (subject to change):

| Operation | v3.0/v3.1 (H2/H3) | P1 |

|---|---|---|

| text_to_model | 10 (no tex) / 20 (tex) | 30 / 40 |

| image_to_model | 20 / 30 | 40 / 50 |

| multiview_to_model | 20 / 30 | 40 / 50 |

| import model | free | — |

Add-ons [Doc]: detailed texture +10, smart low-poly +10, quad +5, generate parts +20,

detailed geometry +20. Post-process: rig 25, retarget 10 per animation, pre-rig check free,

mesh_segmentation 40, mesh_completion 50, smart_lowpoly 30, convert 5 (+5 with options).

Consumer/Studio subscriptions differ from API credit purchasing. Reported tiers [3P], verified

2026-07-10: Basic free (~300 credits/month, 1 concurrent task), Pro/Professional ~$15.90/mo

(~3,000 credits, ~10 concurrent), Advanced ~$39.90/mo (~8,000 credits, ~15 concurrent). Treat exact

dollar/credit figures and tier names as unstable; confirm on tripo3d.ai/pricing before quoting.

Rate limits: exceeding limits returns HTTP 429; concurrent-task limits are plan-dependent

(free ≈ 1). Errors carry a code, message, and suggestion (e.g. code 2002 = unsupported task type).

Handle 429 with backoff and respect the concurrency cap by queueing. [Doc/3P]

Rights & licensing — read carefully, this is a real risk surface

[Doc/1P], verified 2026-07-10:

• On the free/Basic plan, generated models are typically published publicly and released under a

Creative Commons CC BY 4.0-style license — i.e., others may use them with attribution, and you do

not get private/exclusive assets. Do not treat free-tier output as confidential or exclusive.

• Paid plans unlock private models and grant commercial-use rights to the geometry you generate,

which is what production/retail/print use requires.

• Tripo's operating entity retains all IP in its software, models, and technology (Background IP); the

license concerns the *asset you generate*, not the platform.

[Heuristic] Practical guidance for agents:

• For any commercial deliverable, generate on a paid plan and confirm the current Terms yourself

(tripo3d.ai/terms) — licensing wording changes and CC BY 4.0's "commercial-with-attribution" nuance is

easy to misread. Do not assert "you own it, full commercial rights" without checking the plan and terms.

• You are still responsible for the input: do not feed copyrighted/branded characters, trademarked

designs, or images of identifiable real people you lack rights to, and don't launder those into a

"generated" asset. The generator does not grant you rights you didn't have in the source.

• For 3D printing commercial sales, verify both the Tripo license tier and that the design itself

isn't infringing.

Complete worked example (illustration, not a required formula)

Intent: produce an engine-ready, game-budget stylized barrel prop for Unity, from a concept image, then

convert to FBX. Provider/model: Tripo OpenAPI, P1 (want controlled low-poly + oriented asset).

# 1) Create an image_to_model task with P1, budgeting ~4k faces, PBR on, image-aligned orientation.
curl -s https://api.tripo3d.ai/v2/openapi/task \
  -H "Authorization: Bearer $TRIPO_API_KEY" -H "Content-Type: application/json" \
  -d '{
        "type": "image_to_model",
        "model_version": "p1",
        "file": { "type": "png", "url": "https://example.com/barrel_ref.png" },
        "face_limit": 4000,
        "texture": true,
        "pbr": true,
        "texture_quality": "detailed",
        "orientation": "align_image",
        "auto_size": true
      }'
# -> { "code":0, "data": { "task_id": "TASK_A" } }

# 2) Poll until success, then read output URLs and consumed_credit.
curl -s https://api.tripo3d.ai/v2/openapi/task/TASK_A \
  -H "Authorization: Bearer $TRIPO_API_KEY"
# status: queued -> running -> success; data.output has the GLB URL. Download it promptly (URL expires).

# 3) Convert the finished GLB to FBX for the Unity project (chained by task id).
curl -s https://api.tripo3d.ai/v2/openapi/task \
  -H "Authorization: Bearer $TRIPO_API_KEY" -H "Content-Type: application/json" \
  -d '{ "type":"convert_model", "original_model_task_id":"TASK_A", "format":"FBX" }'

Why structured this way: P1 with an explicit face_limit yields a game-budget mesh directly instead of a

million-triangle mesh you'd have to decimate; orientation:"align_image" keeps the pivot/facing predictable

for level design; texture+PBR give lit-pipeline maps; conversion is a cheap chained task off the same id.

Expected result: a ~4k-tri textured barrel, GLB then FBX. Likely failure modes: baked-in shadows from

a harsh reference photo (fix: cleaner lighting or enable_image_autofix); hallucinated back detail (fix:

supply a multiview set); topology too triangulated for later deformation (fix: quad:true or a

smart_lowpoly pass). Variations: swap to multiview_to_model with front/back/left/right renders for a

faithful hero prop; drop to v3.0 and texture:false for a rapid geometry-only silhouette review before

committing credits.

Sources (verified 2026-07-10)

• Tripo OpenAPI docs — Introduction, Quick Start, Pricing, model-generation pages: https://docs.tripo3d.ai/
• Official Python SDK API reference (task types, params, animation presets):

https://github.com/VAST-AI-Research/tripo-python-sdk/blob/master/docs/API.md

• Tripo platform docs (billing, rate limit, error handling, animation): https://platform.tripo3d.ai/docs
• Tripo API product page: https://www.tripo3d.ai/api; Pricing: https://www.tripo3d.ai/pricing
• Tripo blog — H3.1 / Smart Mesh P1.0 announcements (first-party claims): https://www.tripo3d.ai/blog
• Terms / licensing: https://www.tripo3d.ai/terms and 3D-print copyright guide on tripo3d.ai
• Third-party (disclosed, secondary): apidog developer guide https://apidog.com/blog/how-to-use-tripo-3d-api/;

3D AI Studio Tripo P1 docs; fal / Runware Tripo model pages (proxy webhook behavior)