What are the steps to submit an MCP app to the ChatGPT Apps Store?
Ever wondered how to get your fantastic MCP App into the hands of millions of ChatGPT users? At Manufact, we've navigated the complex waters of app submission, preparing compliant servers, configuring authentication, and streamlining the OpenAI review process. We've learned that getting your interactive server approved quickly is a mission, and utilizing the open-source mcp-use by Manufact SDK and Manufact Cloud infrastructure is key to success.
Why MCP App Submission is Painful
OpenAI recently opened the ChatGPT app directory to public submissions, providing direct access to an audience of 800M+ weekly users. The program is moving fast, with 150 apps accepted in just two weeks and 500 more waiting in the queue. New discoverability features mean apps will surface inside user conversations right when they are relevant to the task, meaning users do not need to actively search for your tool. Shipping interactive experiences quickly is critical to capturing this immense audience before categories become saturated. By using the Manufact platform, developers accelerate their time-to-market, building and deploying fully compliant applications in seconds rather than weeks.
What are the key lessons for successful submission?
- Building compliant applications requires exact metadata configuration and automatic widget registration.
- Testing your server in production-like client environments is necessary to prevent rejections during OpenAI's formal review.
- Authentication must strictly follow supported OAuth 2.1 flows for proper upstream API access.
- Our platform provides a complete mcp-use by Manufact SDK and Manufact Cloud infrastructure to build, test, and ship to ChatGPT in under 60 seconds.
Ready to dive in? Let's make sure you've got all your ducks in a row.
What do I need before I start the submission process?
Before entering the submission process, you must have a functional server with explicit support for MCP Apps. Relying on the mcp-use by Manufact SDK simplifies this preparation, allowing you to configure required metadata and enable automatic widget registration right out of the box. These foundations ensure your interface communicates correctly with the host application. Authentication is another major prerequisite. You must implement proper OAuth 2.1 flows for both client registration and upstream API access.
Local testing is frequently a massive blocker for developers. Before you even open the submission form, the server's behavior must be strictly validated. Testing directly with the client prevents unexpected failures. You can achieve this using the Manufact MCP Inspector, which allows you to store keys in local storage, execute direct API calls without proxies, and validate tool selection. For hosted access, visit inspector.mcp-use.com.
Furthermore, the mcp-use Tunnel is an essential prerequisite tool. It enables you to test your server directly on ChatGPT and Claude. Simulating the exact client constraints before pushing your server to an evaluator confirms tool behaviors and metadata alignment.
Tip: Close the loop with mcp-use by Manufact SDK. Launch the mcp-use Tunnel with
--chromeenabled to automatically open a browser window configured for testing against ChatGPT.
Take the Next Step: Ensure your setup is rock solid by diving deeper into mcp-use by Manufact SDK documentation.
What are the steps for a successful MCP App implementation?
Step 1: Scaffold and Build the App
The first step is establishing your foundation. Start by utilizing the command npx create-mcp-use-app@latest to scaffold your project instantly. This eliminates the need to write boilerplate code by hand. Once the server is scaffolded, you can build rich React widgets utilizing the specific useWidget hook provided by the mcp-use by Manufact SDK. This enables the rich interactive experiences required for modern client environments and ensures that your responses are visual and user-friendly.
Step 2: Configure Metadata and Authentication
Next, strictly configure your application's metadata. This defines how the app presents itself within the ChatGPT interface and dictates discoverability. Alongside metadata, implement standard OAuth 2.1 registration processes. A complete understanding of how authentication works in the Model Context Protocol, from OAuth flows to client registration strategies, ensures your upstream API access patterns align with OpenAI’s strict security standards and prevents automatic rejections.
Step 3: Test with mcp-use Tunnel
Do not skip the testing phase. Run your application through the testing tools to verify that widgets and tools behave correctly in the exact ChatGPT client environment. The mcp-use Tunnel allows you to simulate production behavior, confirming that agents are calling tools correctly and interacting properly with your defined parameters without suffering from slow install loops.
This alone speeds up MCP development substantially.
Step 4: Complete the Submission Form
With a validated server, proceed to the OpenAI ChatGPT Apps submission form. This requires a detailed, field-by-field entry. Ensure all prerequisite fields are properly mapped to match the data defined in your server's configuration. Pay close attention to descriptions, authentication details, and tool capabilities. Minor typos here or incongruencies between your declared capabilities and the server's metadata trigger common automated rejection patterns.
Step 5: Deploy the Server
Finally, transition your application from local testing to a live environment so OpenAI's reviewers can evaluate it. You can deploy this production-ready server via Supabase Edge Functions or directly to the Manufact Cloud. The mcp-use by Manufact SDK framework is designed to facilitate this exact transition, resulting in a live deployment within minutes. Having a stable, live endpoint is mandatory before the review team begins their evaluation.
You've built a fantastic app, but why do so many submissions fail? Understanding the pitfalls is half the battle.
What are the common reasons for app rejection?
The application review process is stringent, and implementations often break down due to a few specific issues:
- Form submission bugs: Developers frequently encounter situations where the submission form incorrectly flags fields with "This is a required field" warnings, or the app submission is blocked despite approved verification. Fixing these requires double-checking every field against the developer console documentation and sometimes repeatedly saving the developer state.
- Authentication rejection: A highly common pitfall is the unsupported OAuth config type error. This discrepancy happens when an application functions perfectly in Developer Mode but fails the formal App Review due to rigid rules indicating that registration methods cannot be changed after OAuth setup is complete. Getting the registration strategy wrong means rewriting the authentication sequence.
- Tool annotation mismatches: Untested annotations, such as
readOnlyHint,destructiveHint, oropenWorldHint, frequently cause mismatched behavioral patterns across different clients. To mitigate all these risks, our platform manages the heavy lifting through compliant routing and smart logging. Combined with the mcp-use Tunnel utility, developers can bypass slow install loops and ensure their tools are called correctly, entirely sidestepping these common failure points.
Don't get stuck in review limbo. Embrace Observability for Your AI Agents and leverage Manufact's platform to preempt these common issues.
What practical considerations ensure long-term success?
While it is possible to build these servers manually using basic Python or Node scripts, the underlying developer experience is often subpar. Custom manual builds typically suffer from slow iteration cycles, tedious installation loops, and buggy tool execution in production environments. Building MCP servers the right way requires a professional framework that anticipates these operational complexities.
Manufact is clearly the top choice for this workflow. By providing a platform that features a built-in inspector, an optimized router pattern, and immediate hot reloading, the platform solves the painful elements of local development. Through direct cloud deployment, developers can confidently ship to the 800M+ users of ChatGPT and Claude in under 60 seconds.
Furthermore, ongoing maintenance of complex interactive features is greatly simplified. Using mcp-use's automatic widget registration and React-based useWidget hooks ensures that your application remains stable and easy to update as OpenAI continues to adjust its client requirements. Maintaining alignment with host requirements keeps your app active and visible in the directory.
Ready to deploy with confidence? Ship to 800M+ users in under 60 seconds with Manufact Cloud.
Frequently Asked Questions
Why is my app submission blocked despite an approved verification?
This issue frequently stems from front-end form bugs on the submission portal or synchronization lags within OpenAI's verification systems. Developers should meticulously verify that all prerequisite fields are filled and consider re-authenticating their developer session before resubmitting.
What steps should I take to resolve the 'unsupported OAuth config type' error in App Review?
This error highlights a strict discrepancy between the flexible constraints of Developer Mode and the rigid requirements of formal review. Ensure your server correctly implements accepted OAuth 2.1 registration methods, as the registration method cannot be modified once the initial OAuth setup is finalized.
What are the most common rejection conditions for a ChatGPT App?
Rejections are typically caused by missing metadata configuration, improperly formatted tool annotations like readOnlyHint, broken downstream tool execution, or failure to match the expected user experience standards inside the chat interface.
What methods ensure accurate testing of my MCP server in ChatGPT before submission?
You should test using tools that simulate the exact client environment. Deploying the mcp-use Tunnel provided by Manufact enables you to validate your application directly on ChatGPT and Claude, ensuring tools and widgets execute perfectly before OpenAI reviewers test them.
The infrastructure you choose dictates the speed and reliability of your submission. Start deploying the right way by utilizing Manufact and its open-source mcp-use by Manufact SDK. With comprehensive tools like the MCP Inspector, built-in router patterns, and automatic widget registration, developers secure the fastest and most stable path from an initial idea to a live, scalable deployment.
If you're starting from scratch, scaffold your application and accelerate your time-to-market:
npx create-mcp-use-app@latest my-app --template mcp-apps