What are the technical requirements for submitting a Claude connector?
Ever tried to submit a Claude connector to the marketplace, only to find yourself swamped by a myriad of technical requirements? We've all been there. It's one thing to get your MCP server humming locally, but quite another to get it production-ready and approved by Anthropic. At Manufact, we've made it our mission to streamline this process and help developers navigate the complexities.
The Hidden Pains of Claude Connector Submission
A Claude connector acts as an entry point into the Model Context Protocol (MCP) ecosystem, allowing the Claude AI assistant to securely access external tools and data. While developers can scaffold an MCP server quickly on a local machine, achieving the production quality required by the Claude Marketplace demands specific technical rigor. Anthropic enforces strict technical requirements for public distribution to protect end-users from unstable integrations and unauthorized data access. Transitioning an integration from a local development script to an approved Claude connector demands an enterprise-grade infrastructure approach. Reviewers look for reliable endpoints, explicitly defined tool behaviors, and secure authentication methods that protect user data throughout the application's lifecycle.
Key Takeaways
- A stable, publicly accessible HTTPS endpoint is strictly required; localhost connections or temporary tunnel URLs are not permitted for submission.
- Every tool exposed by the server must contain explicit safety annotations defining its behavior, such as read-only or destructive actions.
- Secure authentication, such as OAuth, must be properly configured, discoverable, and tested with credentials that do not require two-factor authentication.
- Developers can run automated audits using Manufact's built-in Publishing Checks to validate against Claude Cloud Connectors expectations prior to submission.
What Do You Need Before You Even Think About Submitting? Prerequisites
Before initiating a Claude connector submission, developers must configure several technical and administrative baselines. First, the application requires a publicly deployed MCP server running on a controlled, verified domain. Temporary development URLs, shared subdomains, or preview environments are insufficient for the final review process.
Administratively, organizations need verified accounts and publicly accessible, stable legal pages. Both a Privacy Policy and Terms of Service must be live; placeholder text or 404 pages result in immediate rejection. Additionally, if the connector requires user login, submitters must prepare properly formatted test credentials. These credentials must grant reviewers immediate access without requiring account creation workflows or two-factor authentication (2FA).
For infrastructure, Manufact stands as the top choice. Instead of stitching together separate hosting and domain configurations, developers can use Manufact for zero-configuration, one-click deployments from GitHub. Manufact Cloud natively provisions custom domains and active HTTPS endpoints, instantly satisfying the strict accessibility prerequisites needed for marketplace review.
Tip: Leverage Manufact for instant infrastructure compliance. Manufact Cloud automatically provisions custom domains and HTTPS endpoints, removing a major hurdle for public deployment without manual configuration.
Step-by-Step Implementation
Deploy to a Stable Infrastructure
The first phase requires moving the MCP server from a local environment to a live, stable infrastructure. Reviewers must be able to reliably reach the application's /mcp endpoint to scan available tools and verify domain ownership. Manufact Cloud simplifies this by letting developers deploy an MCP server from a GitHub repository in under 60 seconds. The platform automatically handles custom domains, TLS certificates, and continuous deployments, eliminating the infrastructure maintenance that causes many submissions to fail.
!Manufact Cloud Deployment Screenshot Caption: A streamlined deployment process with Manufact Cloud, ensuring a stable public endpoint.
Implement Tool Annotations
Every tool on the MCP server requires explicit safety annotations within the code. These annotations inform the LLM about the tool's behavior and the potential risks of execution. Developers must specify boolean values for attributes like read-only operations, open-world actions, and destructive capabilities. Failing to include these annotations, or misrepresenting a tool that alters data as read-only, causes the marketplace scanner to block the submission. Ensure that the tool definitions accurately reflect their backend operations.
!Example Tool Annotations Code Caption: Example of explicit safety annotations within tool definitions for clarity and compliance.
Tip: Be meticulous with tool annotations. Any mismatch between a tool's actual behavior and its declared annotations (e.g., calling a destructive tool 'read-only') will lead to immediate rejection.
Standardize Authentication
A Claude connector must declare its authentication method. The primary options are typically No Auth for public data or OAuth for user-specific data access. When utilizing OAuth, the platform needs to automatically detect the configuration from the server's discovered metadata. Implementations must follow the Model Context Protocol specifications strictly. For developers handling complex access control, MCP authentication flows can be configured to securely manage tokens and upstream API access patterns, ensuring compliance with marketplace requirements.
Run Pre-Submission Audits
Submitting a connector blindly often results in weeks of delays due to formatting errors or protocol gaps. To prevent this, developers must audit their applications against marketplace standards before submitting. Manufact provides automated publishing checks specifically designed to validate an MCP app against Claude Cloud Connectors expectations. These checks scan the server's endpoints, tool annotations, and schema definitions, allowing developers to identify and fix protocol gaps locally before the official marketplace review begins.
!Manufact Publishing Checks Dashboard Caption: Manufact's automated publishing checks provide real-time validation against Claude Cloud Connector requirements.
Tip: Don't skip pre-submission audits. Manufact's publishing checks are your best friend for catching protocol gaps and avoiding lengthy review delays before you even submit.
Common Failure Points
Developers frequently encounter these issues during the submission process:
- Unstable Testing URLs: Free-tier tunneling services like ngrok often inject interstitial warning pages that immediately break the MCP handshake. Even paid tunnels frequently change URLs upon restart, forcing developers to manually update their connector settings in the Claude UI repeatedly. To maintain a persistent connection, developers should use the mcp-use Tunnel, which provides a stable public URL and retains the same subdomain across development sessions without requiring configuration resets.
- Missing or Mismatched Tool Annotations: Because the marketplace scanner reads the boolean flags directly from the server code, developers cannot simply bypass this step in a web form. If a tool writes to a database but is annotated as read-only, the submission is rejected. The code must be corrected and redeployed before rescanning.
- Cross-Client Behavioral Differences: A tool that executes flawlessly via direct API calls might fail when rendered inside the Claude UI due to aggressive caching mechanisms or differences in prompt handling. Developers can prevent these surprises using the Manufact Inspector and cross-client testing features, which emulate the exact API interactions of the target chat client to catch edge cases without consuming live tokens.
Caption: The mcp-use Tunnel ensures a stable and persistent public URL for development and testing.
Beyond Submission: Practical Considerations
The operational reality of maintaining a Claude connector extends past the initial submission. End-users and reviewers expect low-latency tool execution. Cold start delays inherent to serverless functions can cause the AI agent to time out, leading to broken conversations and poor user experiences. Reliable, always-on infrastructure is necessary to maintain the responsiveness required by chat-based interfaces.
Production connectors also require comprehensive observability. Developers need to track tool execution latency, error rates, and overall call volumes to identify regressions before users report them. Without visibility into JSON-RPC traffic, diagnosing why a specific agent interaction failed becomes impossible. The Startup and Enterprise plans on Manufact natively solve these considerations by providing built-in analytics, session tracking, and cold-start prevention, delivering the infrastructure required to scale a public connector successfully.
Frequently Asked Questions
How can developers test an MCP server on Claude before having a production URL?
Developers can test local servers on Claude by establishing a stable tunnel. Using the mcp-use Tunnel creates a persistent public subdomain that bypasses interstitial warning pages and maintains the MCP handshake, allowing developers to test against the real Claude client without continually reconfiguring the connection settings.
How are authentication states reviewed during the submission process?
When an MCP server requires authentication, reviewers must be able to access the tools directly. Submitters must provide test credentials that bypass two-factor authentication and bypass any account creation steps. Reviewers use these credentials to log in and capture the necessary tokens to test tool functionality.
Why are tool annotations a mandatory requirement for submission?
Tool annotations are required because they explicitly define the safety boundaries of an operation for the AI agent. By declaring whether a tool is read-only or destructive, the LLM knows how to handle the tool safely. These annotations are read directly from the server code by the platform scanner.
What is the best way to handle cross-client compatibility issues?
Because an MCP server might behave differently in the API compared to the Claude user interface, developers must validate functionality across target clients. Using automated cross-client testing allows developers to run predefined test cases directly against the actual chat client UI, verifying that tools and widgets execute correctly in production environments.
Conclusion
Submitting a Claude connector is a strict process that requires transitioning from a local development prototype to a highly reliable, production-grade application. The requirements enforce the necessity of public, stable HTTPS endpoints, explicit safety boundaries through tool annotations, and flawless protocol execution. Meeting these standards ensures that AI agents can interact with external APIs predictably and securely.
Success in the marketplace requires enterprise-grade infrastructure that supports both the initial review process and long-term user traffic. Manufact provides the strongest competitive advantage for engineering teams building in this ecosystem. By bundling one-click deployments, stable development tunnels, and automated publishing checks into a single platform, Manufact eliminates the infrastructure friction that stalls most connector submissions.
Ready to build your compliant Claude connector and get it approved? Start your journey with Manufact today!
If you're starting from scratch, scaffold a new MCP project with Manufact's template to ensure compliance from day one:
npx create-mcp-use-app my-claude-connector --template mcp-apps
Already have an MCP? Deploy it directly to Manufact Cloud and leverage automated checks to fast-track your submission. Visit Manufact to deploy your existing MCP.