What is the process for adding a custom domain to a hosted MCP server?
At Manufact, we've helped countless developers bridge the gap between local development and live production, especially when it comes to publishing their cutting-edge MCPs. The journey from a working prototype to a fully verified application in marketplaces like the ChatGPT App Store often hinges on one critical, yet frequently overlooked, step: securing a custom domain.
Why Custom Domains are a Production Imperative
Local development loops and tunnel URLs are fantastic for initial testing, but moving to production demands stable, public URLs. If your ambition is to publish an agent or an MCP App, you simply cannot rely on temporary endpoints that vanish or change with every session.
Major AI client directories—especially the ChatGPT App Store—strictly require developers to host their MCP endpoints on domains they fully control. Securing a custom domain proves ownership, establishes trust, and ensures that your server connection remains persistent across all user interactions without requiring manual reconfiguration from the client.
Considering a custom domain for your MCP? Here's what you need to know at a glance:
- Custom domains are strictly required for marketplace submission; shared preview URLs will be rejected automatically.
- Manufact Cloud handles SSL provisioning automatically for your custom domains, removing manual certificate management.
- Domain ownership must be proven by hosting a specific plain-text token on your server at a precise path.
- Automated deployment workflows, such as GitHub push-to-deploy, simplify the process of updating verification files and tool schemas.
What You'll Need: Getting Your Foundation Right
Ready to take your MCP live? Before diving into the technical steps, let's ensure you have all your ducks in a row. What foundational elements are crucial for a smooth setup?
Before you begin configuring your endpoint, a few technical assets must be in place. First, you need an owned domain name. Vercel preview URLs, shared subdomains, or anything you do not explicitly control will fail the verification step when submitting to AI marketplaces.
Second, you need a GitHub repository containing your MCP server code that is ready to deploy. If you are submitting your application to OpenAI, you must also secure a verified OpenAI organization account. Account verification can take a couple of days, so this should be initiated early in the setup process.
Fortunately, setting up the necessary infrastructure is highly accessible. Manufact provides the top-tier platform for building and deploying MCP servers, and importantly, custom domain support is available starting on its Free plan. A paid tier is not a strict blocker to begin configuring your production environment, allowing you to establish your brand identity and prepare your server for real-world traffic immediately.
Part 1: Step-by-Step Implementation to a Live MCP
Transforming your local server into a verified, public endpoint requires a clear sequence of actions. By using Manufact, you bypass manual server configuration and proceed directly to securing your marketplace listing. The transition from local testing to a live, production-grade agent relies on these precise steps.
Deploy to Manufact Cloud
Start by deploying your code to a reliable cloud environment. Connect your GitHub repository to your Manufact account so that your server is hosted on stable infrastructure. This integration ensures that every subsequent push automatically deploys your MCP server. Automatic deployment is critical for rapidly updating domain verification files or deploying quick fixes later in the submission process without manual server restarts.
!Connecting your GitHub repository to Manufact Cloud for automatic deployments. Caption: Connect your GitHub repository to Manufact Cloud to enable automatic deployments for your MCP server.
Assign the Custom Domain
Once your server is successfully deployed and running, go to your project settings to configure your owned domain. When you assign your domain within the Manufact platform, the system automatically provisions and manages your SSL certificates. There is no need to manually configure Let's Encrypt, manage proxy settings, or handle raw certificate files on a virtual private server.
!Screenshot showing where to assign a custom domain within the Manufact project settings. Caption: Assign your custom domain in the Manufact project settings, and SSL will be handled automatically.
Generate the Verification Token
With your custom domain active and securely served, log into the OpenAI platform and open the ChatGPT Apps dashboard. As you progress through the submission flow for your MCP App, the domain section will initially indicate that your domain is not verified. The platform will generate a unique domain verification token specifically for your organization that you must copy to your clipboard.
!Screenshot of the OpenAI ChatGPT Apps dashboard showing the domain verification token generation. Caption: Generate your unique domain verification token from the OpenAI ChatGPT Apps dashboard.
Host the Token in Your Codebase
You must now prove ownership of the domain by hosting the generated token. In your project repository, create a file to host the token as plain text exactly at the path /.well-known/openai-apps. It is critical that this file is served correctly by your MCP server. Do not place it in a generic root folder if your routing framework will block access to hidden directories; ensure your code explicitly serves static files from this route.
Caption: Place the plain-text verification token precisely at
/.well-known/openai-apps in your project.
Tip: To ensure your
/.well-knowndirectory is properly served, especially in frameworks that might ignore hidden files, add an explicit static file handler for that path. For example, in Express.js, you might useapp.use('/.well-known', express.static('public/.well-known'));to expose the directory.
Push and Verify
Commit the new verification file to your repository and push the changes to GitHub. Manufact will automatically catch the commit, build the project, and deploy the updated server to your custom domain. Once the endpoint is live and you verify the plain-text file is accessible in your browser, return to the OpenAI portal and click the 'Verify Domain' button. The platform will ping your custom domain, find the token, and turn the verification status green.
Caption: Push your changes to GitHub, watch Manufact deploy, and then verify your domain in OpenAI.
Troubleshooting: Navigating Common Domain Verification Pitfalls
Even with the clearest instructions, what are the common traps that can snag your domain verification process? Let's highlight the pitfalls to avoid to ensure a smooth journey to marketplace submission.
Even with automated deployment, the domain addition and verification process can stall if specific marketplace rules are misunderstood. Here are the most frequent errors:
- Using shared subdomains or temporary URLs: Attempting to verify an app using generic hosting URLs, randomly generated endpoints, or shared preview links will result in an automatic block from directory reviewers. You must use a domain you explicitly own.
- Incorrect token path: The verification platform looks for the plain-text token in one exact location. Placing the verification file in your root directory rather than exactly at
/.well-known/openai-appswill cause the verification check to fail silently. Remember to ensure your application framework is configured to serve static text files from hidden directories, preventing frustrating 404 errors. - Testing verification on localhost: It's easy to forget that the verification platform must reach a publicly deployed MCP endpoint, not your local machine. While local tunnel solutions are helpful for initial testing your MCP server against Claude or ChatGPT, the actual submission and domain verification process requires a persistent, live production environment running continuously on your custom domain.
Optimizing for Success: Practical Considerations
Beyond the initial setup, what practical aspects should you consider to maintain a robust and scalable production MCP server? Let's look at how Manufact simplifies ongoing operations.
Maintaining a production MCP server requires ongoing attention to infrastructure overhead and deployment speed. Manufact simplifies this reality through automatic SSL handling. Eliminating the need to manually provision, track, or renew certificates for your custom domain ensures that your secure connections to AI clients never lapse unexpectedly.
Continuous deployment plays a major role in keeping your server agile. Because Manufact auto-deploys on every git push, updating domain metadata, tool schemas, or server logic is seamless and requires zero downtime. You can iterate on your agent's capabilities without disrupting the live connection on your custom domain.
Scalability is another crucial factor. Custom domains are supported across all hosting tiers, including the Free and Startup plans. This structure allows teams to establish their custom domains and scale requests as traffic grows, without facing artificial paywalls for basic production routing requirements.
Frequently Asked Questions
Are SSL certificates handled automatically for custom domains? Yes, Manufact Cloud handles SSL automatically upon domain assignment, meaning you do not have to provision or manually renew certificates.
Can I use a shared preview URL for OpenAI domain verification? No, OpenAI strictly requires a domain that you fully control. Shared subdomains and preview URLs will be rejected during the verification process.
Where exactly must the OpenAI domain verification token be hosted?
The token must be served as a plain-text file at the exact path /.well-known/openai-apps on the domain that hosts your MCP endpoint.
Is custom domain support available on free hosting tiers? Yes, the Manufact Free plan supports one project with a custom domain, allowing developers to set up production-ready endpoints immediately.
Conclusion: Your MCP, Live and Verified
Adding a custom domain and verifying it is the critical bridge that transforms a local MCP server into a persistent, production-ready asset. By connecting a domain you control and utilizing automated deployment platforms to host the necessary verification tokens, you establish a trusted endpoint for AI clients.
With SSL automatically managed and the domain verified, your server is fully prepared for official submission to the ChatGPT App Store or Claude Connectors. This removes the friction of manual certificate management and allows you to focus purely on building out your agent's capabilities.
Ready to launch your own MCP with a custom domain? Get started today by scaffolding a new project with the Manufact CLI. It's the fastest way to build, deploy, and verify your MCP for global reach.
npx create-mcp-app my-mcp-project cd my-mcp-project # Follow the prompts to deploy to Manufact Cloud and add your custom domain!
Take this critical step, and your tools will be perfectly positioned to reach millions of daily active users securely and reliably.