Best 3D Model Generation APIs for Developers (2026)

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, 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, 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, catalog conversion with 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.

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, quads or triangles, and texture resolution as request parameters, so you skip a 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

The Sloyd 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 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 from text or an image, skybox edit, text to image and 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.

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 or the in-app MCP setup page.

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.

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.

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.

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.

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.

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.

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.

3D Model Generation APIs Compared

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 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.

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 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 and check the rate card on API pricing. To try the output first, generate in the app with text to 3D, image to 3D or the Skybox Generator. For agent workflows, connect the Sloyd MCP server and read about AI agents for game assets. For hard-surface props built by a language model, see LLM text to 3D vs diffusion text to 3D. Building a game? See 3D for game development and our 3D AI price comparison.