Where to Find a Complete Plugin Manifest Example in the OpenAI Plugins Repository

The most complete plugin manifest example lives in plugins/zoom/.codex-plugin/plugin.json, which includes every optional field defined by the plugin schema, making it the definitive reference for building Codex plugins.

A plugin manifest is the JSON configuration file that declares a Codex plugin’s metadata, capabilities, UI branding, and runtime entry points. According to the openai/plugins source code, repository maintainers provide several reference implementations ranging from minimal stubs to production-ready configurations. The Zoom plugin manifest represents the most comprehensive example, demonstrating every supported key and nested object.

Complete Plugin Manifest Example Location

The Zoom Plugin Manifest

The canonical reference for a fully-featured plugin manifest is located at:

plugins/zoom/.codex-plugin/plugin.json

This file serves as the gold standard because it implements every optional field defined by the plugin schema, including complex nested objects for UI branding and capability declarations. You can view the complete file on GitHub to see how a production connector structures its metadata.

Alternative Manifest Examples

For plugins with different scope requirements, the repository provides two additional reference files:

• Metric-pack manifest (plugins/plugin-eval/fixtures/metric-pack/manifest.json): A minimal configuration designed for skill packs, containing only essential metadata keys.
• Minimal plugin manifest (plugins/plugin-eval/fixtures/minimal-plugin/.codex-plugin/plugin.json): A bare-bones definition that demonstrates the absolute minimum required structure for a valid plugin.

Plugin Manifest Architecture

A plugin manifest follows a strict schema defined in plugins/codex-security/schemas/scan-manifest.schema.json. The top-level structure includes the following keys:

• name: The canonical plugin identifier used in prompts and routing. Example: "zoom"
• version: Semantic version of the plugin. Example: "1.0.0"
• description: Short human-readable description of functionality. Example: "Smart meeting insights from Zoom"
• homepage: URL for the plugin’s homepage. Example: "https://developers.zoom.us/"
• repository: Source-code repository URL. Example: "https://github.com/zoom/zoom-plugin-codex"
• author: Object containing author metadata with name and url properties.
• license: SPDX license identifier. Example: "MIT"
• keywords: Array of searchable tags for the plugin catalog. Example: ["zoom", "codex-plugin", "connector"]
• apps: Relative path to the .app.json runtime configuration file. Example: "./.app.json"
• skills: Relative path to the folder containing the plugin’s skills. Example: "./skills/"
• interface: Complex object containing UI-related metadata consumed by the Codex interface.

The interface Object Structure

The interface object controls how the plugin appears in the Codex UI. The Zoom implementation demonstrates the complete schema:

{
  "brandColor": "#0B5CFF",
  "brandColorDark": "#0B5CFF",
  "capabilities": ["Interactive", "Read", "Write"],
  "category": "Communication",
  "composerIcon": "./assets/composer-icon.svg",
  "defaultPrompt": [
    "Search my recent Zoom meetings for the discussion about pricing.",
    "Run /plan-zoom-product for a Zoom integration idea."
  ],
  "developerName": "Zoom",
  "displayName": "Zoom",
  "logo": "./assets/logo.jpg",
  "logoDark": "./assets/logo-dark.jpg",
  "longDescription": "Zoom connects Codex to Zoom meeting context …",
  "privacyPolicyURL": "https://zoom.us/privacy",
  "screenshots": [
    "./assets/screenshot-1.png",
    "./assets/screenshot-2.png",
    "./assets/screenshot-3.png",
    "./assets/screenshot-4.png"
  ],
  "shortDescription": "Smart meeting insights from Zoom",
  "termsOfServiceURL": "https://www.zoom.com/en/trust/terms/",
  "websiteURL": "https://zoom.us"
}

Working with Plugin Manifests Programmatically

Loading a Manifest in Node.js

To load and inspect a manifest at runtime, resolve the path and parse the JSON:

import fs from 'fs';
import path from 'path';

const manifestPath = path.resolve(
  __dirname,
  '../plugins/zoom/.codex-plugin/plugin.json'
);
const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));

console.log('Plugin name:', manifest.name);
console.log('Capabilities:', manifest.interface.capabilities);

Validating Against the Official Schema

The repository includes a JSON schema at plugins/codex-security/schemas/scan-manifest.schema.json for validation. Use a validator like AJV to ensure your manifest conforms:

import Ajv from 'ajv';
import manifest from './plugins/zoom/.codex-plugin/plugin.json';
import schema from './plugins/codex-security/schemas/scan-manifest.schema.json';

const ajv = new Ajv();
const validate = ajv.compile(schema);
if (!validate(manifest)) {
  console.error('Invalid manifest:', validate.errors);
} else {
  console.log('Manifest is valid!');
}

Referencing the Manifest in package.json

For tooling integration, reference the manifest path in your package.json using the codexPlugin key:

{
  "name": "zoom",
  "version": "1.0.0",
  "codexPlugin": "./.codex-plugin/plugin.json"
}

Summary

• The Zoom plugin manifest at plugins/zoom/.codex-plugin/plugin.json provides the most complete example, including all optional fields for UI branding and capabilities.
• Minimal examples exist in the plugin-eval/fixtures/ directory for skill packs and bare-bones implementations.
• Every manifest must conform to the schema defined in plugins/codex-security/schemas/scan-manifest.schema.json.
• Key top-level keys include name, version, interface, apps, and skills, with interface controlling all visual and functional metadata.
• You can programmatically validate manifests using the official JSON schema to catch configuration errors before deployment.

Frequently Asked Questions

What is the file path for the complete Zoom plugin manifest example?

The complete example is located at plugins/zoom/.codex-plugin/plugin.json in the openai/plugins repository. This file contains every supported configuration option, making it the definitive reference for the plugin manifest schema.

What are the required fields in a Codex plugin manifest?

At minimum, a valid plugin manifest must include name, version, description, and interface. However, the Zoom example demonstrates that production plugins should also specify author, license, keywords, apps, and skills to enable full platform integration.

Where can I find the JSON schema for validating plugin manifests?

The official validation schema is located at plugins/codex-security/schemas/scan-manifest.schema.json. You can use this file with validators like AJV to programmatically check your manifest structure against the repository's requirements.

How do I reference the plugin manifest in my package.json?

Add a codexPlugin field to your package.json that points to the relative path of your manifest file. For example: "codexPlugin": "./.codex-plugin/plugin.json". This allows build tools and the Codex CLI to locate your plugin configuration automatically.

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