API Page

Meshy API: What Developers Should Verify Before Integrating

A developer-focused page covering the public API facts, authentication, task model, rate limits, retention rules, and the point where automation starts making sense.

Open API docs Read workflow first

Official Meshy API documentation screenshot used for the API page.

Quick Answer

Meshy does have a real public API, but the right time to use it is after you have already proved the manual workflow. The docs publicly describe bearer-key auth, async task creation, plan-based rate limits, and short retention for non-Enterprise API assets.

Verified API Facts

Fact	Source implication	Developer implication
REST interface	Meshy describes the API as RESTful and uses predictable resource URLs with JSON responses.	Developer implication: you can integrate it from standard HTTP stacks without relying on a proprietary client.
Authentication	The quickstart docs say API keys are created in Meshy settings, use the msy-random-string format, and are sent as Bearer tokens in the Authorization header.	Developer implication: secure key handling matters immediately, but authentication itself is straightforward.
Test mode	Meshy publishes a test-mode key that does not consume credits and returns sample task results.	Developer implication: you can wire up request flow and response parsing before spending real credits.
Async task model	The quickstart docs explicitly say Meshy uses an asynchronous execution model that returns a task ID first.	Developer implication: you need polling or webhooks instead of assuming a one-call synchronous result.
Rate limits	The rate-limit docs publish both requests-per-second and queued-task limits by plan tier.	Developer implication: throughput planning depends on both API RPM and concurrent generation caps.
Retention	The asset-retention docs say non-Enterprise API-generated assets are kept for up to 3 days.	Developer implication: download and store outputs yourself if they matter after testing or post-processing.

API fact-check note

Last checked: July 23, 2026

Sources checked: Meshy API quickstart, Meshy API rate limits, Meshy API retention, Meshy API pricing, Meshy API landing

What may change: Endpoints, version paths, rate limits, retention windows, and pricing can change. Verify the live docs before coding against assumptions.

API Overview

The public docs frame Meshy as a task-based API for text-to-3D, image-to-3D, remesh, texturing, and related workflows. The biggest architectural fact is that the API is asynchronous. You create a task, receive an ID, and then poll or subscribe for completion.

Authentication

Meshy says API keys are created in the API settings page and use the format msy-random-string. Requests use the Authorization header with a bearer token, and the quickstart examples expect MESHY_API_KEY as the environment variable name.

The docs also provide a test-mode key, msy_dummy_api_key_for_test_mode_12345678, for development. It does not consume credits and returns sample task data shaped like production responses.

Minimal Example

This example follows the public quickstart pattern for a Text to 3D preview request plus status polling.

import os
import time
import requests

headers = {
    "Authorization": f"Bearer {os.environ['MESHY_API_KEY']}"
}

generate_preview_request = {
    "mode": "preview",
    "prompt": "a monster mask",
    "should_remesh": True,
}

generate_preview_response = requests.post(
    "https://api.meshy.ai/openapi/v2/text-to-3d",
    headers=headers,
    json=generate_preview_request,
)
generate_preview_response.raise_for_status()
preview_task_id = generate_preview_response.json()["result"]

while True:
    preview_task_response = requests.get(
        f"https://api.meshy.ai/openapi/v2/text-to-3d/{preview_task_id}",
        headers=headers,
    )
    preview_task_response.raise_for_status()
    preview_task = preview_task_response.json()
    if preview_task["status"] == "SUCCEEDED":
        break
    time.sleep(5)

Rate Limits / Credits

Tier	Requests per second	Queued tasks	Priority note
Pro	20	10	Default
Studio	20	20	Higher than Pro
Enterprise	100	50 by default, customizable	Highest

Pricing trigger

The public API docs say generation usage is credit-based and pay-before-you-go. The public product site also says Pro includes API access, so developers should compare the live pricing page with the API pricing docs before building around a specific plan assumption.

Asset Retention / Privacy

Meshy's asset-retention docs say API-generated assets are retained for up to 3 days if you are not an Enterprise customer. Enterprise customers can retain them indefinitely. That means your integration should download outputs and persist them outside Meshy if the assets matter after generation.

SDK / Stack Notes

I did not find a public official SDK that I would hard-promise here, so I am not naming one. The public docs clearly support standard HTTP usage and now also mention an MCP path for AI coding assistants, but if you want a formal SDK guarantee you should confirm the current docs directly.

When Not to Use the API

Do not integrate the API just because automation sounds good. If the manual prompt-to-output process is still too noisy, the API will only make it easier to spend credits on the wrong work. Prove the workflow by hand first, then automate the stable part.

Pricing Trigger

Read Pricing next if your main question is which plan unlocks enough access for the API to be realistic. Read Workflow next if you are not yet sure the underlying generation flow is good enough to automate at all.

Go to pricing Go to workflow

API FAQ

Does Meshy have a public API?

Yes. Meshy publishes official API docs and public quickstart material for text-to-3D, image-to-3D, and related endpoints.

How does Meshy API authentication work?

Meshy uses an API key passed in the Authorization header as a Bearer token. The docs say keys follow the format msy-random-string.

Is there a Meshy API test mode?

Yes. The quickstart docs include a test-mode API key for development that does not consume credits and returns sample task results with the same response structure.

What rate limits should developers care about first?

The first limits to watch are requests per second and concurrent queued generation tasks. Those shape how fast you can submit work and how many jobs can run at once.

How long does Meshy keep API-generated assets?

The asset retention docs say non-Enterprise API-generated assets are retained for up to 3 days, so you should download and store outputs yourself.

When should I not use the Meshy API yet?

Do not automate too early. If you have not already validated the manual workflow, the API will only automate the wrong steps faster.

Which Meshy plan matters for API users?

API users should check Pro and above first, then compare the live plan details with the API pricing and rate-limit docs before building around assumptions.