Mint — an AI 3D pipeline that turns prompts, photos and 360 captures into GLB models and explorable worlds, composes them into one scene, and can be driven by a coding agent over MCP

• Mint

  This page

  PricingRoughly even

  • Credits pay for generation, and they come in two kinds: a one-time welcome grant that never expires and can be spent without any subscription, and an included monthly allowance that resets while a plan is active
  • Mint spends the included allowance first and falls back to the non-expiring credits, so unused grant credit is not quietly burned while you are paying
  • Plans are optional and, by the vendor’s own wording, their price and allowance are shown on the account card rather than published as a fixed public tier table
  • New top-ups are no longer sold, which means the credit balance is a grant or a plan allowance rather than something you top up on demand
  • The pre-generation step is billed separately from the final asset, and previews can be created even when the balance cannot cover the finished model

• 3D AI Studio

  PricingRoughly even

  • A one-time pack or a monthly subscription, both denominated in credits, with monthly allowances resetting each cycle and purchased packs staying put
  • Free credits on sign-up with no card, which is the most generous entry of the four and the reason it often wins an evaluation
  • Free tools inside the toolkit — texturing, remeshing, level-of-detail work — that cost nothing on any plan, so the paid credits are spent on generation rather than tidying
  • The engine choice does not change the price, so switching between the wrappers it resells is free of commercial consequence

• Meshy

  PricingRoughly even

  • A permanently free tier with a small monthly allowance that resets, plus paid subscription tiers that raise the allowance, concurrency and queue priority
  • The free allowance does not accumulate, so unused monthly credits are simply lost
  • Paid tiers bundle commercial rights and private assets, which the free tier does not confer
  • Separately purchased credits sit outside the subscription cycle and do not expire, which softens the reset

• Tripo

  PricingRoughly even

  • A permanently free tier with a modest monthly allowance, then subscription tiers that scale the allowance alongside concurrency and queue priority
  • Concurrency is the axis this vendor organises its tiers around, so the step up from free is really a purchase of parallel work rather than of capability
  • Commercial use and private models are gated behind the paid tiers, while the free tier keeps assets public and non-commercial
  • A separate one-off credit purchase exists for people who want volume without a subscription

1. Mint — official site
2. Mint — plans, Credits and billing
3. Mint — documentation
4. Mint — API overview
5. Mint — Credits and usage
6. Mint — MCP server for agents
7. Mint — 3D model generation
8. Mint — terms of service (FKR Inc)
9. Mint — privacy policy
10. 3D AI Studio — official site
11. Meshy — official site
12. Tripo — official site

Free tier

Yes

Pricing summary

The billing model is credits, but the two kinds of credits matter more than the number on any plan card. The one that arrives with a new account is a welcome grant: it does not expire and it can be spent without a subscription, which is genuinely free access rather than a time-limited trial, and it is the path most people should use to find out whether the output is good enough. The other kind is the monthly allowance attached to a plan, which resets on the vendor’s schedule and is spent first while a plan is active, so a paying user does not quietly eat their permanent credits. Two consequences follow. First, this is not a freemium product in the sense of a recurring free allowance — the vendor states plainly that there is no free trial, and once the welcome grant is gone, generation is paid. Second, credits behave more like a prepaid balance than a subscription meter, because new top-ups are no longer sold: what you have is what came with the account or with a plan. That makes estimating cost before spending unusually valuable, and the API reflects it — an estimate endpoint returns the conservative total for an operation together with the amount required to start it, without creating anything or reserving credits. It exists because generation here happens in two stages: Worlds, Models and Asset Packs produce a cheap preview first and the expensive final asset second, and the estimate lets a tool show both figures before committing. The steps are billed as separate checks, so a preview can be created even when the remaining balance would not cover the finished asset, and a rejected or unaffordable final step simply leaves the preview sitting there. Plans are optional, and the vendor treats the in-product account card as the authoritative statement of price and allowance rather than a published table, so the structure described here is the part that stays stable — the numbers are worth confirming in the account screen and in the documentation before you budget from them.

Reviewed on 24 September 2026 · Mint — plans, Credits and billing

• Models from text or a reference image

  The core generation flow turns a description or one clear reference image into a downloadable GLB, with a saved asset on the account that later work builds on rather than a one-off download. Style and topology guidance can be supplied up front. Follow-up actions — optimisation for delivery, cleaner quad topology, format conversion — are applied to the finished model, which is the difference between a generator and a starting point for a pipeline.

• Worlds built from captures, photos and links

  A second kind of output is an explorable environment rather than an object: prompts, images, Street View links, listing links, mobile photos or a guided 360 video capture can all become a World, and existing public Worlds can be remixed. This is the capability with no real equivalent among the tools this page compares it to, and it is the one where the phone app and the browser do genuinely different jobs.

• Compose several assets into one published scene

  Multiple models and worlds can be combined into a single large scene and published on the web for anyone to open and move through, which is the framing the product leads with on its own homepage. That shifts the unit of work from a file to a destination: the deliverable is a link someone can visit rather than a download someone has to import.

• Asset Packs rather than one-off models

  A single request can produce a coherent set — a game kit, a prop collection, a vehicle lineup, a furniture or plant set — instead of one object at a time. Packs are checked and generated as batches, and rigging can be applied to models inside a pack. For game and environment work this is the feature that removes the most manual repetition, because consistency across a set is normally the expensive part.

• Materials, audio and scene dressing

  Seamless textures, PBR material sets and coordinated Material Packs are generated alongside the geometry, and audio can be produced for scenes — sound effects, ambience, short music cues. Having these in the same pipeline as the geometry means a scene does not have to leave the tool to become presentable.

• A preview stage before you pay for the result

  Worlds, Models and Asset Packs generate a fast visual proposal first, and the final asset is a separate, more expensive step. Generation can run straight through, or pause for review so the preview is approved or revised with concrete feedback. It is a small workflow detail with a large effect on cost, because it makes a bad direction cheap to catch.

• An MCP server and a REST API for agents

  A remote MCP endpoint with OAuth lets a coding agent create and retrieve 3D assets directly, and the documentation ships agent skills for the recommended integration path. Underneath sits an HTTP API covering models, worlds, asset packs, materials, images, audio, video and animation, built on long-running operations with approve, revise, retry and cancel verbs. This is the part of the product that a browser-only tool cannot match.

• Engine and DCC bridges

  A Blender plugin and download manifests for other integration points mean generated assets can be pulled into the tools where the work continues rather than manually exported and dragged across. Download URLs, file manifests and an integration manifest are part of the API surface, so the handoff can be automated rather than performed by hand.

1. 1

   Use the preview stage deliberately, not passively

   Generating through to the final asset is faster, and reviewing the preview first is cheaper when the direction is wrong. The habit worth building is to leave review on while you are still deciding what the thing should be, then switch to straight-through once the prompts are proven. The preview is a visual proposal rather than a rough version of the final mesh, so judging it as geometry is a mistake — judge whether the shape and silhouette are the right idea.

2. 2

   Estimate before you spend

   The API exposes an estimate endpoint that returns both the credits needed to start a step and a conservative total for the operation, without creating anything or reserving credit. It is the single most useful habit in the product, because it turns cost from a surprise into a figure you can show a user or check against a balance, and it is the one detail that makes an agentic pipeline safe to leave running.

3. 3

   Generate the set, not the object

   If the work needs more than one asset that belongs together — a kit, a roster, a set of props — ask for the pack rather than assembling it from individual generations. Consistency between pieces is the cost that normally eats the time, and the batch flow is built for exactly that. It also converts a repetitive task into a single review, which is where agent workflows pay off most.

4. 4

   Plan the follow-up steps into the pipeline

   Raw generated geometry is rarely the shippable artifact. Optimisation, cleaner topology and format conversion are separate actions on the finished asset, and rigging and animation are separate again. Deciding which of those your pipeline needs, and in what order, matters more than prompt tuning: an asset that has to be retopologised by hand later has not saved the time it appeared to.

5. 5

   Bring the agent in at the right level

   Connecting a coding agent over MCP is easy, and it is tempting to point it at everything at once. It works better when the agent owns retrieval and the repetitive steps — listing assets, fetching manifests, downloading files, regenerating failures — and a person owns the direction. An agent that generates freely is an agent that spends freely, which is why the estimate and usage endpoints belong in its loop rather than beside it.

6. 6

   Decide what is publishable before you publish

   Anything published to the public side of the product is visible to others and covered by a licence allowing the service to display and promote it, and remixing means other people build on what is public. That is a feature when the goal is to share a scene and a problem when a client asset ends up in Explore by accident. Decide per project, not per account, which worlds are meant to be seen.

• Game teams producing environment and prop volume

  Asset Packs, engines bridges and the option to rig and animate in the same place map directly onto populating a level or a kit rather than modelling one hero object. The value is not that any single piece beats a specialist generator, it is that a coherent set arrives together and lands inside the engine without a manual export step.

• Three.js and web 3D developers

  The combination of GLB output, a published scene a visitor can open, and an API for everything downstream is a good fit for interactive web work. A pipeline that fetches a model, converts it and drops it into a scene can run unattended, which is the difference between using a generator occasionally and building on one.

• Teams that already drive work through coding agents

  A remote MCP endpoint with OAuth and published agent skills makes this a tool an agent can actually operate: create assets, poll long-running operations, fetch manifests and download files. For anyone who has already moved parts of their pipeline into an agent, 3D is usually the step that breaks the chain.

• People turning places and objects into explorable scenes

  Worlds generated from photos, 360 captures, map and listing links are a different deliverable from a model — somewhere to walk around rather than something to import. Property, retail, education and exhibition work all fit, and the mobile capture app exists for exactly that path.

• Anyone who needs to evaluate AI 3D output cheaply

  The welcome credit grant does not expire and works without a subscription, and the estimate endpoint makes the next step legible before it is taken. For a studio deciding whether generated geometry belongs in its pipeline at all, that is a low-stakes way to find out, with a reviewable preview as the stopping point if the answer is no.

This is a pipeline, not an editor

Mint generates, refines, composes and publishes 3D content, and it exposes all of that through an interface and an API. It is not a modelling application: there are no direct-manipulation tools for pushing vertices, and no sculpting. If the requirement is to shape geometry by hand, a generative pipeline starts you one step too late, and the output will be a starting point that still needs a modeller.

Preview and final generation are separately billed steps

Worlds, Models and Asset Packs check and reserve the preview cost first and the final cost second, so a preview can be created even when the balance cannot cover the finished asset, and an unaffordable final step simply waits. Asset Packs and Material Packs are checked as complete batches rather than partially generated, and the quality setting is never silently downgraded to fit a balance. Those rules are worth knowing because they determine what a failed generation actually costs.

Credits are a grant or an allowance, not a wallet

The terms state plainly that credits are not money, stored value or property, that they are not transferable or refundable outside the purchase flow, and that subscriptions renew automatically unless cancelled. The welcome grant never expires and works without a plan; plan allowances reset. New top-ups are no longer sold. Combined with the public tier table being replaced by the in-product account card, the practical advice is to treat the account screen as the source of truth for both price and balance.

Publishing is public by design

The product has an Explore surface with public Worlds and creator profiles, and content can be favourited, hidden, shared, embedded, downloaded or remixed. Publishing grants the service a licence to display, distribute and promote that content in connection with Mint, and deletion is handled around backup, security, legal, billing and abuse-prevention requirements rather than instant erasure. Assets kept private are private; anything published should be treated as public and reusable.

The agent surface is the differentiator, and it is real

A remote MCP server with OAuth, a documented REST API on long-running operations, an estimate endpoint, usage and balance endpoints, download manifests and an integration manifest add up to something a program can drive end to end. That is a higher bar than exposing a generation endpoint, and it is the reason this tool is interesting to a developer audience rather than only to artists — the automation is the product, not an add-on.

What it does not do

It does not run offline or on-device: generation, hosting and world streaming are cloud services. It does not offer a permanent free tier, so a project that must keep generating indefinitely needs a plan. It does not provide the direct modelling, sculpting or CAD-accurate parametric control that a modelling or CAD tool does. It does not guarantee a specific output format beyond what its exports and bridges cover, and it does not manage the rest of a game pipeline — rigging conventions, engine integration and performance budgets in the target runtime are still yours to own.