# Best 3D Model Generation APIs for Developers (2026)

Compare the Sloyd, Meshy, Tripo, Hyper3D Rodin, Stability AI and 3D AI Studio APIs, plus Hunyuan3D and TRELLIS on fal, on endpoints, async jobs, price per model, polycount control, formats, limits, MCP and output licensing.

_Martin Truong · 2026-10-30 · 3D Modeling_

---
A **3D model generation API** lets your product turn a sentence or a photo into a textured mesh without an artist in the loop. In 2026 that is an HTTP call, and the hard part is picking the API that fits your pipeline and budget.

Some APIs return a GLB in the response, others a job id to poll. Some bill cents per model, others need a $120 subscription first. This guide compares the main options, starting with the [Sloyd API](/api), with every competitor price read from the vendor's own page on 30 October 2026.

## What Is a 3D Model Generation API?

A 3D model generation API is a web service that takes a text prompt or one or more images and returns a 3D model file, usually a [GLB](/glossary/glb-gltf), that your code can store, display or post-process. Most run as async jobs, because a textured model takes seconds to minutes.

Typical uses are user-generated content with [text to 3D](/text-to-3d), catalog conversion with [image to 3D](/image-to-3d), and bulk asset pipelines run by a script or an AI agent. For where the API sits between your engine, viewer and storage, read our guide to [3D model API integration across platforms](/blog/api-integration-for-3d-models-across-platforms).

## What to Look For in a 3D Generation API

The best 3D generation API is the one whose output you can ship without cleanup, at a cost per model your margins survive.

### 1. Endpoints Beyond Text and Image to 3D

Check for multi-image input, retexturing, parts, external model upload, and image or skybox endpoints, so you don't need a second vendor.

### 2. Sync or Async Jobs

A synchronous API returns the file in the response. An async API returns a job id to poll or receive by webhook, which scales better for long renders and batches.

### 3. Price per Usable Model

Compare the cost of a textured model, not the "from" price. Texturing, quads and extra views often double the base cost.

### 4. Polycount and Topology Control

Look for a target [polygon count](/glossary/polygon-count), quads or triangles, and texture resolution as request parameters, so you skip a [retopology](/glossary/retopology) pass later.

### 5. Rate Limits, SDKs, MCP and Licensing

Concurrency decides how fast a batch finishes, SDKs and MCP how fast you integrate, and the license whether you can sell the output.

## The Best 3D Model Generation APIs

The main 3D model generation APIs in 2026 are Sloyd, Meshy, Tripo, Hyper3D Rodin, Stability AI and 3D AI Studio, plus Hunyuan3D v3 and TRELLIS 2 hosted on fal.

### 1. Sloyd API: One REST API for 3D, Images and Skyboxes

![A wireframe treasure chest on the left and the same chest fully textured on the right, illustrating untextured and textured output](/blog-assets/best-3d-model-generation-apis/wireframe-to-textured-model.avif)

The [Sloyd API](/api) generates and edits 3D assets from one base URL, `https://api.sloyd.ai/api`, authenticated with an `x-client-id` and `x-client-secret` header pair. Every generation endpoint is an async job.

**Endpoints:**

- **3D generation:** text to 3D, image to 3D, and multi-image to 3D from up to four views.
- **Model tools:** retexture, and [split a model into parts](/blog/how-to-split-a-3d-model-into-parts-with-ai) with `numberOfParts` (4 to 16) and optional `attachmentPoints` pins for printing. Both work on uploaded models too (GLB, OBJ, FBX, STL, BLEND, PLY, USDC or USDA, up to 500 MB, free upload); a partition split needs a GLB of 16 MB or smaller.
- **Environments and images:** 360-degree [skyboxes](/skybox) from text or an image, skybox edit, [text to image](/text-to-image) and [image editing](/ai-image-editing).

**Geometry control:** text to 3D and image to 3D take `targetFaceCount` up to 500,000, `topology` of `quads` or `triangles`, and `textureResolution` from 128 up to `4k`, or `none` for a geometry-only mesh.

**Pricing:** prepaid credits at 75 credits per USD, with a minimum purchase of USD 12 for 900 credits. A textured model from text costs 25 credits (about $0.33) and from one image 20 credits (about $0.27). Quads add 5 credits, multiple images 10, and a polycount of 500K or above 10. Retexture is 15, split to parts 40 and a skybox 25. Failed jobs are refunded, and API credits are separate from web app plans. Full rate card: [Sloyd API pricing](/api/pricing).

**Limits and licensing:** while the API is in test, each account runs up to 5 concurrent jobs, shared with any web app jobs on the same account, with no per-second limit. Sloyd's Terms of Use allow personal and commercial use of models from the Sloyd web app, with a custom license for commercial 3D printing; confirm API output terms with Sloyd support.

**MCP:** the same keys and credits work in a hosted MCP server at `https://api.sloyd.ai/api/mcp` with 14 tools (10 for generation and editing, plus image upload, job status, credit balance and styles) for Claude Code, Cursor, VS Code and your own agents. See our [guide to MCP servers for 3D model generation](/blog/best-mcp-servers-for-3d-model-generation) or the [in-app MCP setup page](https://app.sloyd.ai/mcp).

**Where it is not the answer:** no official SDK, no webhooks and no list-jobs endpoint. Rigging and animation are not yet enabled for public keys, and the API docs only document a GLB download. For rigging over an API now, use Meshy or Tripo.

**Pick it when:** you want one vendor for models, textures, parts, skyboxes and images, with polycount and quads set per request and no subscription, from USD 12 prepaid.

### 2. Meshy API: The Broadest Feature Set

Meshy has the widest API surface: text, image and multi-image to 3D, retexture, remesh, UV unwrap, rigging, animation, auto split and 3D printing endpoints.

**Pricing (checked on 30 October 2026):** with meshy-7.1 or meshy-6, image to 3D with 2K textures is 30 credits, a text to 3D preview is 20 credits plus 10 to refine with texture, retexture is 10, rigging 5 and remesh 5. API access starts at the Pro plan. Check Meshy's pricing page for current plan prices.

**Developer details:** async tasks with polling, server-sent events or webhooks. Output in GLB, FBX, OBJ, USDZ, STL and 3MF, with BLEND via conversion. Quad or triangle remeshing, and a Smart Topology mode with `target_polycount` from 100 to 30,000. All paid plans allow 20 requests per second; Pro runs 10 concurrent tasks, Premium 30 and Ultra 100. Meshy ships an MCP server as an npm package. Paid plans are listed as "Private & Customer owned"; the free plan is CC BY 4.0. API files are kept only for a short time outside Enterprise, so download results promptly.

**Pick it when:** you need rigging, animation or print preparation in the same API, and a subscription fits your billing.

### 3. Tripo API: SDKs and Clean Topology

Tripo's v3 API covers text, image and multiview to 3D, texturing, conversion, segmentation, retopology, rigging and retargeting.

**Pricing (checked on 30 October 2026):** credits cost $0.01, prepaid from $1. On the mainstream H3.1 model, a textured model is 20 or 30 credits from text ($0.20 or $0.30) and 30 or 40 from an image ($0.30 or $0.40), with quads 5 credits extra. The P2 clean-topology model costs 100 credits untextured and 110 to 130 textured ($1.10 to $1.30). Retopology v3.0 is 35 credits for triangles and 40 for quads.

**Developer details:** async tasks polled at `GET /v3/tasks/{task_id}`, plus webhooks. Official SDKs for JavaScript, Python, Go, Rust and Java, a CLI that can run as an MCP server. P2 takes a `face_limit` of 48 to 50,000 triangles or 48 to 25,000 quads. Conversion to GLTF, FBX, USDZ, OBJ, STL and 3MF. Default concurrency is 10 tasks for H-series generation, 5 for P series, and 1 to 10 for other categories. The API docs don't state an output license as of 30 October 2026; check Tripo's terms.

**Pick it when:** you want official SDKs, webhooks, a low per-model price on H3.1, or quad meshes at low face counts. See also our [Tripo alternatives](/blog/top-tripo-alternatives-for-3d-model-generation).

### 4. Hyper3D Rodin API: High-End Detail

Hyper3D's Rodin Gen-2.5 takes a prompt or one to five images, and its highest settings reach textures up to 12K and an extra mesh of up to 10 million faces.

**Pricing (checked on 30 October 2026):** a Gen-2.5 generation is 0.5 credits, plus 0.5 for the Extreme-High tier and 2.0 for extreme-high textures. API access needs the Business plan at $120/month ($96/month billed yearly, "about 416 models").

**Developer details:** async submit, status and download calls, with a per-account cap on parallel tasks and a 429 response when throttled. The docs name GLB, FBX and USDZ outputs, a `quality` preset and a `quality_override` face count, and a `mesh_mode` (the spec doesn't list their full ranges). Paid plans list "Unlimited export and any use". The docs don't mention an MCP server.

**Pick it when:** fidelity matters more than cost and you can commit to a monthly plan. See also our [Hyper3D alternatives](/blog/top-hyper-3d-alternatives-for-3d-model-generation).

### 5. Stability AI 3D API: Lowest Published Dollar Price in This Comparison, Synchronous

Stability AI's two image-to-3D endpoints, Stable Fast 3D and SPAR3D, return the GLB directly in the HTTP response.

**Pricing (checked on 30 October 2026):** Stable Fast 3D is 10 credits and SPAR3D 4 credits per successful generation, at $0.01 per credit, so $0.10 and $0.04.

**Developer details:** image input only, no text prompt. Texture resolution 512, 1024 or 2048, remeshing to triangles or quads, and a vertex or face target of up to 20,000. The general limit is 150 requests in any 10-second window.

**Pick it when:** you need a fast, cheap, synchronous image to 3D call for previews or low-poly props.

### 6. 3D AI Studio API: Many Models Behind One Key

3D AI Studio routes one key to several model families (Hunyuan 3D Pro and Rapid, Hitem3D, TRELLIS.2, and Tripo including P2) plus texturing, remeshing and printing tools.

**Pricing (checked on 30 October 2026):** credit prices vary by model and edition, so check each model's page in its API docs. Prepaid credits expire after 365 days, and the API docs don't state the dollar price of a credit.

**Developer details:** async jobs polled at a status endpoint, no webhooks yet, and a default limit of 3 requests per minute. Output is typically GLB, with conversion to OBJ, FBX, STL, PLY, USDZ and 3MF. Results are deleted after 24 hours. It has an MCP connector, and its FAQ grants commercial use and full rights to outputs. More in our [3D AI Studio alternatives](/blog/top-3d-ai-studio-alternatives-for-3d-model-generation).

**Pick it when:** you want several model families on one contract and low volume.

### 7. Hosted Models on fal: Hunyuan3D v3 and TRELLIS 2

fal hosts partner and open models behind pay-per-request queue APIs.

**Pricing on fal (checked on 30 October 2026):** Hunyuan3D v3 image to 3D is $0.225 for geometry, $0.375 for a normal generation and $0.45 for low poly, with PBR materials, multi-view input and a custom face count each adding $0.15. TRELLIS 2 is $0.25, $0.30 or $0.35 at 512p, 1024p and 1536p. Both return GLB.

**Licensing:** fal tags both as commercial use, but read the model license too. Hunyuan3D v3 is a Tencent partner model on fal; the license of the older open-weights Hunyuan3D 2.1 excludes the EU, UK and South Korea. TRELLIS.2's code is MIT.

**Pick it when:** you want raw model access at a known price and will build post-processing yourself.

## How to Choose a 3D Model Generation API

Choose by the job your users need done, then check price per usable model.

1. **Users type what they want in your app:** text to 3D with polycount control and no subscription, such as Sloyd or Tripo.
2. **You convert product photos:** image to 3D with polycount and texture resolution set per request from Sloyd, or multi-image to 3D from Sloyd, Meshy or Rodin.
3. **You need rigged characters now:** Meshy or Tripo.
4. **You need parts for printing or kits:** Sloyd's split to parts with attachment pins, or Meshy's auto split.
5. **You need the lowest published per-call dollar price in this comparison:** Stability AI at $0.04 to $0.10 per model.
6. **An agent does the work:** pick an API with an MCP server, then read our guide to [AI agents for creating game assets](/blog/best-ai-agents-for-creating-game-assets).

![The same stylized sci-fi hovercraft at three polygon counts, from low poly to high detail, illustrating polycount control](/blog-assets/best-3d-model-generation-apis/polycount-levels.avif)

## How the Sloyd API Request Flow Works

Every Sloyd generation follows the same loop on every endpoint: POST a job, poll it, download the result (a GLB for 3D models).

1. **Create a key** in the API dashboard and buy at least USD 12 of credits.
2. **POST a job,** for example `POST /jobs/text-to-3d` with a prompt and geometry options.
3. **Poll** `GET /jobs/{jobId}` every few seconds until `status` is `success` or `error`.
4. **Download** the GLB from `https://storage.googleapis.com/ai-services-quality/jobs/{jobId}.glb`.

```js
const base = 'https://api.sloyd.ai/api'
const headers = {
  'Content-Type': 'application/json',
  'x-client-id': process.env.SLOYD_CLIENT_ID,
  'x-client-secret': process.env.SLOYD_CLIENT_SECRET,
}

const created = await fetch(`${base}/jobs/text-to-3d`, {
  body: JSON.stringify({ prompt: 'a low-poly pine tree', targetFaceCount: 5000, textureResolution: '2k', topology: 'triangles' }),
  headers,
  method: 'POST',
})
if (!created.ok) throw new Error(`Sloyd ${created.status}: ${await created.text()}`)
const { jobId } = await created.json()

let job
do {
  await new Promise((resolve) => setTimeout(resolve, 5000))
  const res = await fetch(`${base}/jobs/${jobId}`, { headers })
  if (!res.ok) throw new Error(`Sloyd ${res.status}: ${await res.text()}`)
  job = await res.json()
} while (job.status !== 'success' && job.status !== 'error')

if (job.status === 'success') console.log(`https://storage.googleapis.com/ai-services-quality/jobs/${jobId}.glb`)
```

Keep the secret on your server. A `402` means the balance is too low and nothing was charged; a `429` means five jobs (API or web app) are already running on that account.

![A stylized toy robot split into separate parts in an exploded view](/blog-assets/best-3d-model-generation-apis/split-into-parts.avif)

Post-processing works the same way: pass a finished `jobId` (plus a `prompt` for retexture) to `POST /jobs/retexture` or `POST /jobs/split-to-parts` and poll the new job. To preview splits, try [Split to Parts in the app](https://app.sloyd.ai/split-to-parts).

## 3D Model Generation APIs Compared

| API              | Inputs                     | Job flow        | Textured model price                         | Topology and polycount control         | Output                          | MCP or SDK             |
| ---------------- | -------------------------- | --------------- | -------------------------------------------- | -------------------------------------- | ------------------------------- | ---------------------- |
| Sloyd            | Text, image, up to 4 views | Async, poll     | 20 to 30 credits ($0.27 to $0.40)            | Faces to 500K, quads or tris, to 4K    | GLB (documented)                | Hosted MCP, plain REST |
| Meshy            | Text, image, multi-image   | Async, webhooks | 30 credits on meshy-6 and 7.1                | Quad or tri remesh, target polycount   | GLB, FBX, OBJ, USDZ, STL, 3MF   | MCP server (npm)       |
| Tripo            | Text, image, multiview     | Async, webhooks | $0.20 to $0.40 on H3.1, $1.10 to $1.30 on P2 | 48 to 50K tris or 25K quads on P2      | Converts to FBX, USDZ, STL      | 5 SDKs, CLI as MCP     |
| Hyper3D Rodin    | Text, 1 to 5 images        | Async, poll     | 0.5 credits base, Business plan              | quality_override face count, mesh_mode | GLB, FBX, USDZ                  | Not stated             |
| Stability AI     | One image                  | Sync, GLB back  | $0.04 (SPAR3D), $0.10 (Fast 3D)              | Up to 20K, quads or tris               | GLB                             | REST only              |
| 3D AI Studio     | Text, image, multiview     | Async, poll     | Varies by model (see docs)                   | Per model                              | GLB, converts to FBX, USDZ, 3MF | MCP connector          |
| Hunyuan3D on fal | Image, multi-view          | Async queue     | $0.375 + $0.15 for PBR                       | Custom face count +$0.15               | GLB, OBJ                        | fal client libraries   |

Competitor details were read from each vendor's own pricing page or API docs on 30 October 2026. Credits are not comparable across vendors unless a dollar figure is shown, and "Not stated" means the vendor's docs don't list it as of that date, so check the vendor before you build.

## Common Mistakes When Choosing a 3D Generation API

The most common mistakes are comparing base prices, exposing the API secret, and ignoring file retention, polycount and concurrency limits.

- **Comparing base prices.** Texturing, quads and extra views are add-ons almost everywhere; price the request you will actually send.
- **Shipping the secret in the client.** Every API here bills the key holder. Call it from your back end.
- **Ignoring file retention.** Meshy and 3D AI Studio delete API files after a short retention period. Copy results to your own storage.
- **Leaving polycount on auto for real-time use.** Set a face budget up front; read [how to optimize 3D models for real-time use](/blog/how-to-optimize-3d-models-for-real-time-generation) for targets.
- **Forgetting concurrency.** With five or ten concurrent jobs, a 200-model batch runs in waves; queue on your side.

## FAQ

### What is the best 3D model generation API in 2026?

It depends on the job. Sloyd covers text, image and multi-image to 3D plus retexture, parts, skyboxes and images with polycount control from USD 12 prepaid. Meshy and Tripo lead on rigging and SDKs, Rodin on fidelity, and Stability AI on price for simple image to 3D.

### Is there a free 3D model generation API?

Not for production. Sloyd needs prepaid credits from USD 12, Tripo from $1, Meshy's API starts at the Pro plan and Rodin's at Business. Self-hosting open models such as TRELLIS removes per-call fees but needs your own GPUs, and hosted TRELLIS 2 on fal starts at $0.25 per model.

### How much does it cost to generate a 3D model with an API?

Where vendors publish dollar prices, a textured model costs from $0.04 to about $1.30 per call, checked on 30 October 2026. Stability AI's SPAR3D is $0.04, Tripo H3.1 text to 3D $0.20, a textured Sloyd image to 3D model about $0.27, Hunyuan3D v3 on fal $0.375 before add-ons, and Tripo P2 $1.10 to $1.30.

### Which 3D generation APIs let me control the polygon count?

Sloyd accepts a `targetFaceCount` up to 500,000 with quads or triangles. Meshy takes a `target_polycount` with remeshing or Smart Topology, Tripo P2 a `face_limit` up to 50,000, and Stability AI a vertex or face target up to 20,000. Fal charges $0.15 extra for a custom face count on Hunyuan3D.

### Can AI agents use a 3D generation API through MCP?

Yes. Sloyd runs a hosted MCP server at `api.sloyd.ai/api/mcp` with 14 tools on the same keys and credits. Meshy publishes an MCP server package, Tripo's CLI can run as one, and 3D AI Studio offers an MCP connector. See our [MCP server comparison](/blog/best-mcp-servers-for-3d-model-generation).

### Are Sloyd API credits included in a Sloyd Plus or Pro plan?

No. API credits are prepaid separately at 75 credits per USD, from a USD 12 minimum, and they don't expire on a billing cycle. Web app plans on the [pricing page](/pricing) cover the app only, and neither balance draws from the other.

### Can I use AI-generated 3D models commercially?

Usually, on paid tiers. Sloyd's Terms of Use allow commercial use of web app models, with a custom license for commercial 3D printing (confirm API output terms with support); Meshy lists paid output as customer owned, and 3D AI Studio grants full rights. Free tiers and open-weights licenses can add attribution or regional limits, so check each one.

## Build 3D Generation into Your Product

Stability AI has the lowest published per-call dollar price in this comparison, Meshy and Tripo go furthest into rigging, and Rodin pushes detail. Sloyd fits teams that want models, parts, skyboxes and images from one key, with geometry set per request.

Start on the [Sloyd API page](/api) and check the rate card on [API pricing](/api/pricing). To try the output first, generate in the app with [text to 3D](https://app.sloyd.ai/create-3d?mode=text), [image to 3D](/image-to-3d) or the [Skybox Generator](/skybox). For agent workflows, connect the [Sloyd MCP server](https://app.sloyd.ai/mcp) and read about [AI agents for game assets](/blog/best-ai-agents-for-creating-game-assets). For hard-surface props built by a language model, see [LLM text to 3D vs diffusion text to 3D](/blog/llm-text-to-3d-vs-diffusion-text-to-3d). Building a game? See [3D for game development](/use-case/game-development) and our [3D AI price comparison](/blog/3d-ai-price-comparison).

---

Source: https://www.sloyd.ai/blog/best-3d-model-generation-apis