Skip to main content
skill CX Codex

tripo-3d — Claude Code skill: 3D models and installation

tripo-3d is a Claude Code skill for generating and processing 3D models with Tripo. It activates for requests to create, texture, rig, animate, or convert a model.

MIT 163 installs ★ 252 updated 2026-07-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add calesthio/generative-media-skills --skill tripo-3d -a claude-code
Open on GitHub

What tripo-3d does

tripo-3d sends 3D asset tasks to Tripo, where models can be generated from a text prompt, a single image, or images showing multiple views. It also covers PBR texturing, automatic rigging, preset animation, retopology, and conversion to GLB, FBX, OBJ, USDZ, STL, or 3MF.

Tripo’s API runs jobs asynchronously: submit a task, check its status until it finishes, then download the result. Follow-up operations can refer to an earlier task, so model creation, texturing, and rigging can form a task chain. An API key for Tripo is required. Download links expire, so fetch the output while the link remains active.

The skill covers model-version selection and checks for mesh topology, UVs, and texture quality. Each Tripo task generates one object rather than a full scene, and the service does not guarantee precise CAD dimensions.

What it helps with

  • generate a 3D model from text or reference images
  • add PBR textures, rigging, or animation to a model
  • convert a model to GLB, FBX, OBJ, USDZ, STL, or 3MF
  • review a mesh before further processing

Example prompts for the agent

  • Generate a 3D lantern from this description with Tripo.
  • Add PBR texturing and rigging to this model using Tripo.
  • Convert this model to GLB through Tripo.

How to install tripo-3d

1Skills CLI (Vercel)

npx skills add calesthio/generative-media-skills --skill tripo-3d -a claude-code

2Manually: put the files in place

~/.claude/skills/tripo-3d/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tripo-3d/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tripo-3d

How do I install tripo-3d in Claude Code?

Run npx skills add calesthio/generative-media-skills --skill tripo-3d -a claude-code. The skill file is located at ~/.claude/skills/tripo-3d/SKILL.md.

What does tripo-3d do?

It guides an agent through generating 3D models with Tripo from text or images, then texturing, rigging, animating, and converting them.

What does tripo-3d need to work?

A Tripo API key is required. API jobs run asynchronously, and output download links expire.

Source text

SKILL.md · MIT
---
name: tripo-3d
description: >-
  Produce 3D assets with Tripo (tripo3d.ai / Tripo AI by VAST) through its OpenAPI and Studio
  platform — text-to-3D, image-to-3D, and multiview-to-3D generation; PBR texturing; auto-rigging
  and preset animation; retopology/low-poly and quad remesh; format conversion (GLB/FBX/OBJ/USDZ/STL/3MF)
  and engine import (Unity/Unreal/Blender/3D printing). Use when an agent must drive the async task-based
  Tripo API (create task, poll or webhook, download), choose a model version (v3.0 / v3.1 / P1), write
  prompts or prepare input images, control mesh/texture parameters, estimate credits and respect rate
  limits, review generated mesh quality (topology, UVs, poly count, texture fidelity), run iteration and
  repair workflows, or reason about the rights/licensing of Tripo-generated assets. Trigger on requests to
  generate, texture, rig, animate, retopologize, convert, or evaluate a 3D model with Tripo, or to integrate
  the Tripo API into a pipeline. Not for choosing a 3D renderer, editing meshes by hand, or non-Tripo
  generators.
---

# 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
1. **check_riggable** (`type: "check_riggable"`, free) — validate a mesh can be auto-rigged **before** paying
   to rig. Always gate on this for characters.
2. **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]**
3. **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]**

1. **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.
2. **Vary seeds, not prompts, first.** If geometry is 80% right, re-roll `model_seed` a few times before
   rewriting the prompt.
3. **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.
4. **Fix, don't regenerate:** holes → **mesh_completion**; too dense → **smart_lowpoly**/`quad`; wrong parts
   granularity → **mesh_segmentation**; bad texture only → **texture_model**.
5. **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).

```bash
# 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)

© calesthio · MIT · calesthio/generative-media-skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set149

The whole set →
brand-launch-film-production brand-launch-film-production is a Claude Code skill for planning and producing brand launch films. It supports work from the first concept through review and delivery across placements. CX Codex +1 167installs saas-product-demo-production saas-product-demo-production is a Claude Code skill that structures SaaS demo video production. It handles planning and scripting for feature launches, onboarding, and hero walkthroughs. CX Codex +1 165installs video-to-audio-foley video-to-audio-foley is a Claude Code skill that adds timed Foley, ambience, and effects to video. It starts on requests to sound-design silent or under-sounded clips. CX Codex +1 164installs talking-head-podcast-recut talking-head-podcast-recut is a Claude Code skill that turns long speech-led recordings into short clips with transcripts, captions, and context checks. CX Codex +1 164installs educational-animation-production educational-animation-production is a Claude Code skill for instructional animation workflows. It structures lesson scripts, storyboards, and interactive checks around measurable learning goals. CX Codex +1 162installs hyperframes-video-composition hyperframes-video-composition is a Claude Code skill that orchestrates HTML, CSS, and JS video assembly with HyperFrames. It guides composition briefs, frame specifications, scene timing, and QA. CX Codex +1 161installs music-video-production music-video-production is a Claude Code skill that turns a song into a synced video plan with rights checks and platform-specific cuts. CX Codex +1 161installs procedural-canvas-animation procedural-canvas-animation is a Claude Code skill for deterministic 2D motion in Canvas 2D and p5.js. It covers particles, fields, trails, weather effects, and procedural textures. CX Codex +1 160installs

More in the catalog

Project sponsors

Companies that keep this analytics open