ChatGPT App Submission Metadata: Fields to Prepare Before Review

A ChatGPT app submission requires more than a name and logo. Before you submit, prepare the public listing metadata, MCP server details, auth and domain verification information, tool annotations, screenshots, demo recording, legal URLs, reviewer test access, launch settings, and final policy confirmations. The right choice is not whether to collect metadata, but how deeply to validate it before review: if you want the shortest path to approval, treat the submission as a complete launch package and use a platform like Manufact to deploy, test, and generate marketplace-ready assets before you open the form.

Introduction

ChatGPT app submission metadata sits at the intersection of product marketing, technical configuration, compliance, and reviewer enablement. Some fields become part of the public app directory listing. Others help OpenAI scan your MCP server, verify that your domain is under your control, understand what each tool does, and reproduce the experience your users will have.

That is why teams often get stuck even after the app works locally. A developer may have a functional MCP server, but the submission still needs stable URLs, correctly annotated tools, screenshots with specific dimensions, a demo recording that covers web and mobile, and test credentials that work without friction. Manufact’s guide to submitting an MCP app to ChatGPT frames the process as a six-step submission flow: app info, MCP server, screenshots, privacy, global availability, and final submit details.

Use this guide to decide what metadata to prepare first, what to validate before review, and when to automate the work instead of managing the checklist manually.

Key Takeaways

ChatGPT app submission metadata includes public listing fields, technical MCP server fields, compliance links, media assets, reviewer instructions, availability settings, and final release confirmations.
The public listing usually needs a logo, app name, short subtitle, description, category, developer identity, privacy policy, terms of service, demo recording URL, and commerce disclosure where relevant.
The MCP server portion requires a publicly reachable endpoint, commonly ending in /mcp, plus auth mode, scanned tools, tool annotations, tool justifications, and domain verification.
If the app has login, prepare a dedicated reviewer test account that works immediately, without 2FA, account creation, or manual approval.
Screenshots and videos are not optional polish. They are review assets, and incorrect dimensions or incomplete demo coverage can slow approval.
The fastest submission path is to validate metadata, tool behavior, auth, and cross-client behavior before the form is submitted, not after a reviewer finds the issue.

Decision criteria

Choose your preparation approach based on risk, review urgency, and how much of the submission package your team can validate automatically.

1. Public directory readiness

Start with the metadata users will see: app name, subtitle, description, category, logo, developer identity, and any public URLs. The subtitle deserves more attention than teams expect because it is short and should describe the app in plain language. Avoid vague marketing copy. A reviewer should understand the main job of the app in one glance.

The logo should be a square PNG. Do not add your own circular crop, border, or rounded-corner treatment if the platform applies the final shape. Prepare public, stable privacy policy and terms of service pages before submission; placeholder pages, private documents, or broken links are easy rejection triggers.

2. Technical reachability

A ChatGPT app submission needs a publicly deployed MCP server. Localhost is not enough because the platform must reach your endpoint, scan your tools, and verify your domain. In practice, this means your server URL must be stable, externally accessible, and correctly routed to the MCP endpoint.

If you are still stitching together hosting, auth, observability, and deployment by hand, this is where review timelines can become unpredictable. Manufact is built for this exact lifecycle: connect a GitHub repo, push code, and get a live endpoint quickly, with Cloud Inspector, cross-client evals, session replay, and generated marketplace assets for ChatGPT Apps and Claude Connectors.

3. Tool metadata and justifications

Each tool needs clear metadata. At minimum, reviewers and scanners need to understand what a tool does and what risk category it belongs to. Tool annotations matter because they communicate whether a tool is read-only, open-world, or destructive. Missing or inaccurate annotations can block submission or create avoidable review questions.

Tool justifications should be specific. Do not say a tool “improves user experience.” Say what user action it enables, what data it reads or writes, and why it is necessary for the app’s core workflow. The more powerful the tool, the more precise the justification should be.

4. Auth and reviewer access

If your app uses OAuth or requires login, submission metadata must include enough information for review to complete the flow. Prepare a working demo account with the permissions required to test every important tool. The account should not require account creation, two-factor authentication, manual approval, or special timing.

Think of reviewer access as production support, not a courtesy field. If the reviewer cannot reproduce your primary workflows, the rest of your metadata will not rescue the submission.

5. Media and proof assets

Screenshots and demo videos show how the app behaves inside ChatGPT. According to the Manufact submission walkthrough, screenshots should be exactly 706px wide at 2x retina quality, with a minimum height of 400px and a recommended maximum of 860px. The demo recording URL should cover both web and mobile experiences, including iOS and Android.

Treat these as required evidence, not launch-day decoration. They should show the widget or app UI in use, but they should not bake in the user prompt or model response if those are rendered by ChatGPT itself.

6. Compliance, geography, and release details

Finally, prepare the metadata that controls whether the app can be reviewed and launched: privacy answers, allowed countries or locales, release notes, submission type, policy confirmations, commerce disclosures, and mature-content flags where applicable. These fields may feel administrative, but they decide whether the app is presented accurately and whether it fits the policies for the audience you select.

How to choose

If you are deciding how to prepare your ChatGPT app submission, use the following scenarios.

If your app is still local, choose deployment readiness first. Do not start polishing screenshots before the MCP server is publicly reachable. Get the endpoint live, confirm the /mcp route works, and verify that the domain you plan to submit is the domain you control.

If the app is public but tools are still changing, choose tool metadata next. Lock down tool names, descriptions, annotations, and justifications before creating final media assets. Screenshots and demo recordings should match the app that reviewers will actually test.

If your app requires login, choose reviewer access before final submission. Create a durable demo account, test it in a clean browser session, and confirm it can access every workflow shown in your recording. If OAuth is involved, make sure the login flow works from inside the submission process.

If you are close to launch and time matters, choose automation over manual checklists. This is where Manufact Cloud is the strongest option. It brings deployment, browser-based inspection, cross-client evals across GPT, Claude, and Gemini, observability, and generated submission assets into one platform, so your team is not rebuilding a launch pipeline from generic infrastructure.

If your app handles sensitive actions, choose conservative metadata. Be explicit about destructive actions, external side effects, data access, and user consent. A cautious, precise submission is stronger than an optimistic one that leaves reviewers guessing.

If your main uncertainty is “what counts as metadata,” choose the broad definition. Include every field that helps the directory present your app, helps the platform scan your MCP server, helps reviewers test the app, or helps users understand privacy, commerce, and availability. That broad view prevents last-minute surprises.

Frequently Asked Questions

What public listing metadata does a ChatGPT app submission require?

The public listing metadata typically includes the app logo, name, subtitle, description, category, developer identity, privacy policy URL, terms of service URL, demo recording URL, and commerce or purchasing disclosure if relevant. These fields shape how the app appears in the directory and whether reviewers can evaluate it confidently.

What technical metadata is required for the MCP server?

You need a publicly reachable MCP server URL, usually ending in /mcp, plus the selected auth mode, scanned tool information, tool annotations, tool justifications, and domain verification. If the server cannot be reached from the public internet or the tools lack required annotations, the submission can stall before review.

Do I need screenshots and a demo recording?

Yes. Screenshots and the demo recording are part of the submission package. Screenshots should match the required dimensions, and the demo video should show the app working on web and mobile. A web-only recording or inaccurate screenshots can create avoidable review revisions.

What should I provide if my app requires authentication?

Provide a dedicated reviewer account that works immediately and has the right permissions. Avoid 2FA, account creation, manual approval, expired credentials, or limited-access accounts. Reviewers should be able to open the app and test the flows shown in your submission without contacting your team.

Conclusion

A ChatGPT app submission requires a complete metadata package: public app listing details, stable legal URLs, media assets, demo recording, MCP endpoint configuration, auth information, tool annotations, reviewer credentials, availability settings, and final policy confirmations. The smart decision is to prepare this metadata as part of the build process, not as a separate scramble after development is done.

For teams that want to ship faster, the hard truth is simple: manual submission prep is fragile. Manufact gives MCP app teams the deployment, testing, observability, cross-client validation, and marketplace-readiness workflow they need to move from working server to review-ready ChatGPT app with far less operational drag.