# Meshy

```json
{
  "name": "Meshy",
  "slug": "meshy",
  "url": "https://composio.dev/toolkits/meshy",
  "markdown_url": "https://composio.dev/toolkits/meshy.md",
  "logo_url": "https://logos.composio.dev/api/meshy",
  "categories": [
    "design & creative tools"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-09-12T05:38:13.648Z"
}
```

![Meshy logo](https://logos.composio.dev/api/meshy)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Meshy MCP or direct API to generate 3D assets, render photorealistic images, animate motion sequences, and process and export optimized models through natural language.

## Summary

Meshy is a Creative Lab providing generative 3D, image, motion, animation, and model-processing APIs.
It lets teams quickly create, iterate, and export production-ready creative assets.

## Categories

- design & creative tools

## Toolkit Details

- Tools: 27

## Images

- Logo: https://logos.composio.dev/api/meshy

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Meshy.
  - Setup:
    - Configure Api Key credentials for Meshy.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Generate photorealistic 3D model of chair
- Animate walking cycle for humanoid character
- Optimize and export glb model for web

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `MESHY_CANCEL_CREATIVE_LAB_TASK` | Cancel Creative Lab Task | Cancel a Creative Lab task only while it is PENDING or IN_PROGRESS. Terminal task history is retained. Canceling a PENDING task refunds its credits; canceling an IN_PROGRESS task does not refund credits. |
| `MESHY_CREATE_ANIMATION_TASK` | Create Animation Task | Start a 3-credit task that applies either a selected library animation or a succeeded Text to Motion clip to a completed rigging task and return the animation task ID. |
| `MESHY_CREATE_AUTO_SPLIT_TASK` | Create Auto Split Task | Split a succeeded untextured Meshy 6 or Meshy 7 model into separately printable parts and return the task ID. An accepted task costs 10 credits; failed tasks are refunded, as is a task deleted while still pending. |
| `MESHY_CREATE_COLLAPSIBLE_FIDGET_TASK` | Create Collapsible Fidget Task | Start an entitled 6-credit task that generates a collapsible fidget directly from an image and return the task ID. |
| `MESHY_CREATE_CONVERT_TASK` | Create Convert Task | Start a 1-credit task that converts a model into one or more requested formats; returns the task ID. |
| `MESHY_CREATE_CREATIVE_LAB_BUILD` | Create Creative Lab Build | Start a 3D build from a succeeded matching Creative Lab prototype. Lamp builds cost 6 credits, keycap builds cost 50, and all other builds cost 30. The call returns a build task ID. |
| `MESHY_CREATE_CREATIVE_LAB_PROTOTYPE` | Create Creative Lab Prototype | Start an entitled image-to-prototype task for a fixed Creative Lab product. Lamp prototypes cost 30 credits, keycap prototypes cost 12, and all other prototypes cost 6. The task ID can be passed to the matching build operation. |
| `MESHY_CREATE_IMAGE_TO_3D_TASK` | Create Image to 3D Task | Start a 3D generation task from one to four views of one object or a prior task's input images. One image uses single-image generation and two to four use multi-image generation. Meshy-6/7 cost 20 credits without texture, 30 with texture, or 35 with 8K texture; single-image Meshy T2 costs 5, 15, or 20 respectively; other models cost 5 without or 15 with texture. Ultra on Meshy-7 adds 5 credits. Returns task_id and the exact task_type discriminator for GET_TASK, LIST_TASKS, or DELETE_TASK. |
| `MESHY_CREATE_IMAGE_TO_IMAGE_TASK` | Create Image to Image Task | Start a credit-consuming task that edits or restyles one to five reference images from a text instruction. The task costs 3 to 12 credits depending on the model and returns a task ID for status checks. |
| `MESHY_CREATE_MULTI_COLOR_PRINT_TASK` | Create Multi-Color Print Task | Start a 10-credit task that converts a GLB or FBX model from a prior Meshy task or direct URL into a limited-color 3MF for 3D printing, and return the task ID. When both sources are provided, input_task_id takes precedence. |
| `MESHY_CREATE_PRINT_ANALYSIS_TASK` | Create Print Analysis Task | Start a free task that analyzes a GLB, GLTF, OBJ, FBX, or STL model from a prior Meshy task or direct URL for printability defects and return the task ID. When both sources are provided, input_task_id takes precedence. |
| `MESHY_CREATE_PRINT_REPAIR_TASK` | Create Print Repair Task | Start a 10-credit task that repairs a GLB, GLTF, OBJ, FBX, or STL model from a prior Meshy task or direct URL for 3D printing and return the task ID. When both sources are provided, input_task_id takes precedence. The repaired asset retains the input format. |
| `MESHY_CREATE_REMESH_TASK` | Create Remesh Task | Start a 5-credit task that remeshes a model to the requested topology and polygon count, optionally resizes it, and exports the remeshed result in the requested formats. Use CREATE_CONVERT_TASK for format conversion without remeshing. Returns the remesh task ID. |
| `MESHY_CREATE_RESIZE_TASK` | Create Resize Task | Start a 1-credit task that scales a model by height, longest side, or automatic sizing and return the task ID. |
| `MESHY_CREATE_RETEXTURE_TASK` | Create Retexture Task | Start a credit-consuming task that applies one text, image, or multiview style source to an existing 3D model. The task costs 10 credits at 2k or 4k resolution and 15 credits at 8k, and returns a task ID for status checks. |
| `MESHY_CREATE_RIGGING_TASK` | Create Rigging Task | Start a 5-credit task that rigs a GLB character with a biped or quadruped skeleton and return the task ID. Models above 300,000 faces must be remeshed first. |
| `MESHY_CREATE_TEXT_TO_3D_TASK` | Create Text to 3D Task | Start a new Text to 3D preview or fused geometry-and-texture task and return its task ID. Preview costs 20 credits for Meshy 6/7, 5 credits for Meshy T2 or other models, and Ultra adds 5 credits; fused generation costs 30 credits for Meshy 6/7 or 15 for Meshy T2 and other models. Use REFINE_TEXT_TO_3D_TASK to texture a succeeded preview. |
| `MESHY_CREATE_TEXT_TO_IMAGE_TASK` | Create Text to Image Task | Start a credit-consuming 2D image generation task from a text prompt. The task costs 3 to 9 credits depending on the model and returns a task ID for status checks. |
| `MESHY_CREATE_TEXT_TO_MOTION_TASK` | Create Text to Motion Task | Start an entitled motion-generation task from a text prompt and return its task ID. Prime mode costs 10 credits and the completed task produces FBX; swift mode costs 3 credits and the completed task produces BVH. |
| `MESHY_CREATE_UV_UNWRAP_TASK` | Create UV Unwrap Task | Start a 5-credit task that generates UV coordinates for a GLB model and return the task ID. High-poly models may need to be remeshed first. |
| `MESHY_DELETE_TASK` | Delete Task | Permanently delete a GA or Text-to-Motion task and its retained outputs. Creative Lab tasks cannot be deleted with this action; use CANCEL_CREATIVE_LAB_TASK for an active Creative Lab task. |
| `MESHY_GET_CREDIT_BALANCE` | Get Credit Balance | Return the connected Meshy account's available credit balance before starting paid generation tasks. |
| `MESHY_GET_TASK` | Get Task | Retrieve current status, errors, and available outputs for one task from a selected Meshy task family. This read does not consume credits. |
| `MESHY_LIST_ANIMATION_LIBRARY` | List Animation Library | Search or filter Meshy's unpaginated animation catalog and return action IDs for use when creating animation tasks. |
| `MESHY_LIST_TASKS` | List Tasks | Return one page of tasks for one selected Meshy task family, with an opaque cursor for safe continuation. This read does not consume credits. |
| `MESHY_LIST_USAGE_RECORDS` | List Usage Records | Return one page of terminal API-task usage and consumed credits for the connected Meshy team. This endpoint is available only to Studio and Enterprise team API keys. Pass next_cursor alone to continue the same filtered export; split exports into windows of at most one year. |
| `MESHY_REFINE_TEXT_TO_3D_TASK` | Refine Text to 3D Task | Apply texture to a succeeded Text to 3D preview and return the new refine task ID. Refinement costs 10 credits at 2k or 4k texture resolution and 15 credits at 8k. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Meshy Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Meshy actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'YOUR_SPECIFIC_PROMPT_HERE'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'YOUR_SPECIFIC_PROMPT_HERE'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK for Python or TypeScript
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Initialize Client and Create Tool Router Session

Import and initialize the Composio client, then create a Tool Router session for Meshy
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });
const session = await composio.create('your-user-id');
console.log(`Tool Router session created: ${session.mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent (Anthropic Claude or Mastra)
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Meshy tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('YOUR_SPECIFIC_PROMPT_HERE')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: session.mcp.url,
    headers: {
      'x-api-key': 'your-composio-api-key',
    },
  },
});

const tools = await client.tools();
const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{
    role: 'user',
    content: 'YOUR_SPECIFIC_PROMPT_HERE'
  }],
  maxSteps: 5,
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Meshy Integration

- Supports both Meshy MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for reading, writing, and querying your Meshy data

### 2. Managed Auth

- Built-in OAuth handling with automatic token refresh and rotation
- Central place to manage, scope, and revoke Meshy access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Meshy
- Scoped, least privilege access to Meshy resources
- Full audit trail of agent actions to support review and compliance

## Use Meshy with any AI Agent Framework

Choose a framework you want to connect Meshy with:

- [ChatGPT Work](https://composio.dev/toolkits/meshy/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/meshy/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/meshy/framework/hermes-agent)

## Related Toolkits

- [Figma](https://composio.dev/toolkits/figma) - Figma is a collaborative interface design tool for teams and individuals. It streamlines design workflows with real-time collaboration and easy sharing.
- [Abyssale](https://composio.dev/toolkits/abyssale) - Abyssale is a creative automation platform for generating images, videos, GIFs, PDFs, and HTML5 content programmatically. It streamlines and scales visual content production for marketing, design, and operations teams.
- [Alttext ai](https://composio.dev/toolkits/alttext_ai) - AltText.ai is a service that generates alt text for images automatically. It helps boost accessibility and SEO for your visual content.
- [Are.na](https://composio.dev/toolkits/arena) - Are.na is a creative research platform for collecting images, links, notes, and ideas in channels. Use it to organize inspiration, build knowledge maps, and connect research across projects.
- [Bannerbear](https://composio.dev/toolkits/bannerbear) - Bannerbear is an API-driven platform for generating images and videos automatically at scale. It helps businesses create custom graphics, social visuals, and marketing assets using powerful templates.
- [Bannerbite](https://composio.dev/toolkits/bannerbite) - Bannerbite is a creative automation platform for generating images and videos from reusable projects and templates. It helps teams produce on-brand visual assets faster without rebuilding designs from scratch.
- [Builder.io](https://composio.dev/toolkits/builder_io) - Builder.io is a visual development platform for managing content, models, assets, and Space configuration. Use it to ship editable digital experiences faster without waiting on every code change.
- [Canva](https://composio.dev/toolkits/canva) - Canva is a drag-and-drop design suite for creating professional graphics, presentations, and marketing materials. It makes it easy for anyone to design with beautiful templates and a vast library of elements.
- [Canva MCP](https://composio.dev/toolkits/canva_mcp) - Canva MCP is Canva's remote MCP server for accessing designs and content. It centralizes design assets and enables programmatic design workflows.
- [Claid ai](https://composio.dev/toolkits/claid_ai) - Claid.ai delivers AI-driven image editing APIs for tasks like background removal, upscaling, and color correction. It helps automate and enhance image workflows with powerful, developer-friendly tools.
- [Cloudinary](https://composio.dev/toolkits/cloudinary) - Cloudinary is a cloud-based platform for managing, uploading, and transforming images and videos. It streamlines media workflows and delivers optimized assets globally.
- [Contentdrips](https://composio.dev/toolkits/contentdrips) - Contentdrips is an asynchronous rendering API for branded graphics and carousels. It turns reusable templates into on-brand social visuals at scale.
- [Creatomate](https://composio.dev/toolkits/creatomate) - Creatomate is an API for generating automated videos, images, GIFs, and reusable media templates. Use it to turn structured data into polished visual content at scale.
- [Cults](https://composio.dev/toolkits/cults) - Cults is a digital marketplace for 3D printing models, connecting designers and makers. It lets creators share, sell, and discover a huge variety of printable designs easily.
- [DeepImage](https://composio.dev/toolkits/deepimage) - DeepImage is an AI-powered image enhancer and upscaler. Get higher-quality images with just a few clicks.
- [Dreamstudio](https://composio.dev/toolkits/dreamstudio) - DreamStudio is Stability AI’s platform for generating and editing images with AI. It lets you easily turn ideas into stunning visuals, fast.
- [Dynamic Mockups](https://composio.dev/toolkits/dynamic_mockups) - Dynamic Mockups is an API platform for generating product mockups, rendering templates, and managing visual asset catalogs. Use it to automate high-quality product visuals, AI images, and motion assets at scale.
- [Dynapictures](https://composio.dev/toolkits/dynapictures) - Dynapictures is a cloud-based platform for generating personalized images at scale. Instantly create hundreds of custom visuals using your data sources, like Google Sheets.
- [Eraser MCP](https://composio.dev/toolkits/eraser_mcp) - Eraser MCP is a workspace for creating and managing technical diagrams and structured documents. It helps teams organize, version, and export diagrams with collaboration-focused tooling.
- [Excalidraw MCP](https://composio.dev/toolkits/excalidraw_mcp) - Excalidraw MCP is a no-auth MCP server for creating hand-drawn style diagrams in Excalidraw. Use it to generate visual sketches with viewport camera control and fullscreen editing.

## Frequently Asked Questions

### Do I need my own developer credentials to use Meshy with Composio?

Yes, Meshy requires you to configure your own API key credentials. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)