🚀 I Built a Chrome Extension to Download My Meshy 3D Models — and 50 People Installed It Before Launch

I Built a Chrome Extension to Download My Meshy 3D Models — and 50 People Installed It Before Launch

If you're using Meshy 6 or Meshy 7, you may have already run into this:

You generate a model.

You like the result.

You want the .glb.

You click Download...

And you're asked to upgrade to a Pro plan.

That's the part that caught my attention.

I'm not talking about generating the model. The generation itself is great.

I'm talking about the moment when you already have a 3D asset sitting in your workspace and simply want to get the file onto your computer.

For users who are on a plan that doesn't include that download access, the workflow stops right there.

And that got me thinking:

Could I make the actual download workflow much simpler for users who already have download access?

That's how I started building MeshyGrab.

And here's the part I didn't expect:

MeshyGrab just officially launched, and it's already approaching 50 installs.

So, here's how this little Chrome extension came together.

The problem

The problem is actually pretty simple.

You generate a 3D model inside Meshy.

You can view it.

You can rotate it.

You can inspect it.

But eventually, you need the actual asset outside the browser.

Maybe you want to:

• Open the .glb in Blender
• Import it into Unity or Unreal
• Use it in a game
• Prepare it for 3D printing
• Modify the geometry
• Retopologize it
• Texture it
• Animate it Or simply keep a local copy

And that's where the workflow gets interesting.

The model exists.

You can see it.

But getting the actual file into your own workflow can depend on your Meshy plan.

I wasn't trying to change that.

I just wanted to make the browser-side workflow as painless as possible for users who are entitled to download the model.

---

So I built MeshyGrab

The idea was pretty simple:

What if a Chrome extension could detect the generated model directly from the Meshy workspace and make the download workflow much easier?

Instead of hunting through the interface or dealing with unnecessary steps, the goal became:

Generate → Detect → Preview → Download

That's the entire philosophy behind MeshyGrab.

---

What is MeshyGrab?

MeshyGrab is an independent Chrome extension for Meshy users that helps detect, preview, and download generated 3D models from the Meshy workspace.

The workflow looks like this:

1. Generate your model

Create your model normally inside Meshy.

2. Open MeshyGrab

The extension detects the relevant model information from the workspace.

3. Preview it

The detected model appears inside the extension popup.

4. Download it

If the model is available for download under your Meshy account, you can start the download directly.

That's it.

Generate → Grab → Download.

No separate web application.

No copy-pasting model information between services.

Just a small extension sitting alongside the workflow you're already using.

---

Why a Chrome extension?

Initially, I thought about building this as a separate web application.

But the more I thought about it, the less sense that made.

The model is already being generated inside the browser.

The user is already inside the Meshy workspace.

So why force them to:

1. Copy something
2. Open another website
3. Paste something
4. Wait for another service
5. Download the result

when the browser is already right there?

A Chrome extension felt like the natural solution.

It could live alongside the existing workflow instead of trying to replace it.

---

The interesting engineering part wasn't the popup

The popup UI was actually one of the easier parts.

The interesting challenge was figuring out how to reliably detect the information I needed from a modern web application.

MeshyGrab uses a small browser-side architecture to observe relevant task/model information and communicate it back to the extension.

The flow ended up looking roughly like:

Meshy Workspace

↓

Task / Model Information

↓

Browser-side Bridge / Interception

↓

Extension State

↓

Popup

↓

Download

It looks very simple when written as five arrows.

It wasn't always simple while building it. 😅

Modern web applications don't necessarily expose the information you need in the nice, convenient way you'd hope.

So a lot of the work became understanding what was happening between the page, browser APIs, extension scripts, background logic, and the network layer.

---

Then I had to solve identity

Once MeshyGrab became more than a tiny local utility, another problem appeared.

I needed a way to identify an extension installation reliably.

Chrome extensions have their own lifecycle.

Users can uninstall them.

They can reinstall them.

They can move between browser profiles.

And I didn't want every reinstall to become a completely unrelated installation from the backend's perspective.

So MeshyGrab uses an installation ID as part of its backend identity architecture.

That became particularly important once I started tracking:

• Download entitlements
• Free-download usage
• Persistent download records
• Subscription state

And that brings us to the next problem.

---

A tiny Chrome extension somehow became a SaaS

This is probably my favorite part of the story.

The original thought was:

"I'll just make a tiny Chrome extension."

Then:

"Okay, I need a backend."

Then:

"I need user association."

Then:

"I need download accounting."

Then:

"I need entitlement checks."

Then:

"I probably need abuse protection."

And eventually:

"Apparently I'm building a SaaS now." 😂

The backend ended up handling things like:

• Installation registration
• User association
• Download entitlements
• Free-download accounting
• Persistent download records
• Subscription state
• Abuse protection
• Idempotent download consumption

The stack is currently:

TypeScript + Fastify + Drizzle ORM + PostgreSQL/Neon

The extension communicates with the backend through API endpoints, while the backend handles the persistent state that shouldn't live entirely inside the browser.

---

The free plan

I didn't want someone to install MeshyGrab and immediately hit a paywall.

So the extension includes:

🎁 2 free downloads

That gives users a chance to actually experience the workflow before deciding whether they need more.

For people who use Meshy regularly, there's also:

⭐ Pro — $0.99/month

with unlimited downloads.

The philosophy is simple:

If a tiny tool saves you enough hassle every month, it should be cheap enough to be an easy decision.

---

And then something unexpected happened

This is the part I didn't really expect when I started building it.

MeshyGrab just officially launched.

But it has already reached almost 50 installs during the pre-launch phase.

For a tiny extension built to solve one very specific problem, seeing real people install it before the official launch was honestly pretty motivating.

It also gave me something much more valuable than an analytics number:

validation.

There's a big difference between:

"I think people might want this."

and:

"People are actually installing it."

Almost 50 people installing a product before I've even properly launched it isn't thousands of users, obviously.

But for a solo developer building a very niche tool?

I'll take the win. 😄

---

What I learned building it

The biggest lesson wasn't really about Chrome extensions.

It was about scope.

A project can start with an extremely small idea:

"I want to download this thing more easily."

And suddenly you're thinking about:

• Browser architecture
• Network interception
• Extension state
• Identity
• APIs
• Databases
• Entitlements
• Payments
• Deployment
• Abuse prevention
• Chrome Web Store policies

The actual feature can be tiny.

The infrastructure around it doesn't always stay tiny.

But that's also what makes these projects fun.

You get to touch almost every part of the stack.

---

What's next?

The official launch is the next big milestone.

I'm continuing to work on:

• Reliability
• Better model detection
• Smoother downloads
• Better popup UX
• Edge-case handling
• Performance
• Overall workflow improvements

And I'm also interested in what happens after the download.

Because downloading the .glb is only one step in the AI → 3D workflow.

---

Try MeshyGrab

If you use Meshy and want a simpler way to get your generated 3D models onto your computer:

MeshyGrab — 3D Model Downloader

👉 Extension

🌐 Landing Page

🎥 YT Demo

MeshyGrab is an independent third-party Chrome extension and is not affiliated with or endorsed by Meshy.

---

Final thought

I didn't build MeshyGrab because I thought downloading 3D models was some revolutionary unsolved problem.

I built it because I personally got annoyed by the workflow.

And I figured there were probably other people thinking:

"Why isn't there just a simpler way to get my model?"

So I built it.

Then that tiny idea somehow turned into a browser extension, backend, database, entitlement system, subscription flow, Chrome Web Store submission...

…and almost 50 pre-launch installs. 😄

Not a bad outcome for something that started with:

"This download workflow is annoying."