How OpenAI Reviews and Approves Plugins: A Technical Guide to the ChatGPT Plugin Submission Process

OpenAI reviews plugins through an eight-stage pipeline that validates the .codex-plugin/plugin.json manifest, secures API credentials via the openai-platform-api-key skill, runs automated distribution tests, and enforces security headers before marketplace publication.

The openai/plugins repository contains the reference implementation for the OpenAI Developers plugin ecosystem, codifying the exact steps and validation scripts used during the official review process. Understanding these source-level artifacts enables developers to pass automated checks and expedite manual review stages.

The Eight-Stage Review Pipeline

The OpenAI plugin review process follows a strict sequence defined in the repository's tooling and documentation. Each stage is enforced by specific validation scripts located in the openai-developers plugin skillset.

1. Manifest Preparation and Schema Validation

Every plugin must expose a .codex-plugin/plugin.json manifest describing the plugin name, description, authentication model, and OpenAPI schema. The repository validates this against internal schemas before submission.

According to the openai-developers README, the manifest must reside at the root of the plugin directory and declare all required fields including schema_version, auth, and api specifications.

2. Secure API-Key Handling

The openai-platform-api-key skill encapsulates the creation and safe storage of OpenAI API credentials. It uses an .mcp.json picker to let developers select the API-key name, organization, and destination for the generated .env file, guaranteeing that secrets never leak into version control.

As implemented in plugins/openai-developers/skills/openai-platform-api-key/SKILL.md, this flow ensures API keys are injected at runtime rather than hard-coded.

3. Automated Functional Validation

Before a submission can be sent to OpenAI, the plugin runs through unit tests (node --test …) and the validate_distribution.py script. These checks ensure the plugin can be packaged, that its .codex-plugin assets are well-formed, and that external dependencies are properly declared.

The validation commands are documented in plugins/openai-developers/README.md under local validation procedures.

4. Submission Payload Generation

The chatgpt-app-submission skill generates a chatgpt-app-submission.json file that follows OpenAI's submission schema. This payload includes required fields such as name, description, auth, api, logo_url, and contact_email, which the OpenAI review portal consumes directly.

The skill definition in plugins/openai-developers/skills/chatgpt-app-submission/SKILL.md specifies the exact JSON structure required for marketplace consideration.

5. Security Headers Verification

OpenAI's security team checks that HTTP endpoints enforce required headers including Content-Security-Policy, Strict-Transport-Security, and X-Content-Type-Options. The zoom-apps-sdk skill in the repository provides a concrete checklist for these requirements.

The security requirements are documented in plugins/zoom/skills/zoom-apps-sdk/concepts/security.md, which mandates TLS transmission and minimal OAuth scopes.

6. Privacy and Compliance Review

Reviewers verify that plugins do not store or transmit personally identifiable information without user consent and that GDPR/CCPA compliance statements are present. Any third-party services must be disclosed in the submission metadata.

7. Functional and UX Validation

The plugin is exercised in a sandboxed ChatGPT session to confirm that declared actions work as advertised, error messages are user-friendly, and the UI respects ChatGPT App design guidelines including consistent iconography and clear onboarding flows.

8. Final Marketplace Approval

Once checks pass, the plugin is approved for publication on the ChatGPT Plugin Store. The store entry pulls logo_url and description from the submission payload, making the plugin discoverable by end-users, as outlined in plugins/zoom/skills/general/use-cases/marketplace-publishing.md.

Key Repository Components

The plugin.json Manifest

The plugin manifest serves as the source of truth for the review system. It must be located at .codex-plugin/plugin.json within the plugin directory structure.

The chatgpt-app-submission Skill

Located at plugins/openai-developers/skills/chatgpt-app-submission/, this skill automates the creation of the submission JSON required by OpenAI's review portal. It extracts metadata from the plugin manifest and generates the standardized payload.

Security Validation Requirements

The repository enforces security through the zoom-apps-sdk skill documentation, which specifies mandatory headers and TLS requirements. All plugins must implement these protections to pass the security review stage.

Code Examples

Creating the Plugin Manifest

The following plugin.json structure satisfies the schema requirements enforced by validate_distribution.py:

{
  "schema_version": "v1",
  "name_for_human": "My Awesome Plugin",
  "name_for_model": "my_awesome_plugin",
  "description_for_human": "Enables ChatGPT to fetch data from MyService.",
  "description_for_model": "Fetches and formats data from MyService's API.",
  "auth": {
    "type": "oauth",
    "client_url": "https://myservice.com/oauth/authorize",
    "scope": "read:data"
  },
  "api": {
    "type": "openapi",
    "url": "https://myservice.com/openapi.yaml",
    "has_user_authentication": true
  },
  "logo_url": "https://myservice.com/logo.png",
  "contact_email": "[email protected]",
  "legal_info_url": "https://myservice.com/terms"
}

This structure mirrors the example in plugins/openai-developers/README.md.

Generating the Submission Payload

Use the chatgpt-app-submission skill to generate the required submission JSON:

node plugins/openai-developers/skills/chatgpt-app-submission/generate.mjs \
  --manifest .codex-plugin/plugin.json \
  --logo https://myservice.com/logo.png \
  --contact [email protected] \
  > chatgpt-app-submission.json

The output file chatgpt-app-submission.json is what you upload to the OpenAI developer portal for review, as specified in plugins/openai-developers/skills/chatgpt-app-submission/SKILL.md.

Securing API Credentials

Provision API keys securely using the openai-platform-api-key skill:

node plugins/openai-developers/skills/openai-platform-api-key/create-key.mjs \
  --org my-org \
  --dest ./env/.env

This command writes an .env file containing OPENAI_API_KEY=sk-… only after the user confirms the destination path, ensuring keys never appear in console logs or source code, per the implementation in plugins/openai-developers/skills/openai-platform-api-key/SKILL.md.

Implementing Required Security Headers

Install middleware to enforce the headers required by OpenAI's security review:

// In your server middleware
app.use((req, res, next) => {
  res.setHeader('Content-Security-Policy', "default-src 'self'");
  res.setHeader('Strict-Transport-Security', 'max-age=63072000; includeSubDomains; preload');
  res.setHeader('X-Content-Type-Options', 'nosniff');
  next();
});

This implementation satisfies the requirements documented in plugins/zoom/skills/zoom-apps-sdk/concepts/security.md.

Summary

• Manifest Validation: The .codex-plugin/plugin.json file must declare schema version, authentication, and API specifications according to plugins/openai-developers/README.md.
• Credential Security: The openai-platform-api-key skill ensures API keys are generated and stored securely via .mcp.json configuration, never hard-coded.
• Automated Testing: Plugins must pass node --test unit tests and validate_distribution.py checks before submission.
• Submission Format: The chatgpt-app-submission skill generates the standardized JSON payload consumed by OpenAI's review portal.
• Security Requirements: Endpoints must implement CSP, HSTS, and X-Content-Type-Options headers as specified in plugins/zoom/skills/zoom-apps-sdk/concepts/security.md.
• Privacy Compliance: Reviewers verify GDPR/CCPA compliance and PII handling practices before approval.
• Least-Privilege OAuth: Only minimal required scopes are permitted for authentication flows.

Frequently Asked Questions

How long does the OpenAI plugin review process take?

The automated validation stages complete within minutes, but the manual security, privacy, and functional review stages typically require several business days depending on queue depth and complexity. Plugins requiring additional security scrutiny or those implementing file-system access may face extended review periods.

What security headers are mandatory for OpenAI plugin approval?

According to plugins/zoom/skills/zoom-apps-sdk/concepts/security.md, all plugin endpoints must include Content-Security-Policy, Strict-Transport-Security with a max-age of at least 63072000 seconds, and X-Content-Type-Options: nosniff. All data transmission must occur over TLS.

Can I update my plugin after it is approved and published?

Yes, updates require re-submission through the chatgpt-app-submission skill with a new version identifier in the manifest. The update process re-runs validate_distribution.py and security checks, though typically faster than initial review if the changes are minor bug fixes or feature additions.

What happens if my plugin fails the OpenAI review?

If automated checks fail, the validate_distribution.py script outputs specific errors regarding manifest schema violations or missing headers. For manual review failures, OpenAI provides feedback through the developer portal regarding security, privacy, or UX issues that must be resolved before re-submission via the chatgpt-app-submission skill.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}