OpenAI Plugins: 8 Real-World Examples from the Official Repository

OpenAI plugins are self-contained bundles that expose a declarative manifest and reusable skills, enabling AI models to perform actions like generating code from Figma designs, querying Supabase databases, or automating Zoom meetings.

The openai/plugins repository hosts a curated collection of production-ready plugins that extend AI capabilities beyond text generation. These plugins enable models to interact with external services, fetch data, and execute actions across design tools, databases, and SaaS platforms.

What Are OpenAI Plugins?

OpenAI plugins are self-contained bundles that expose a declarative manifest (.codex-plugin/plugin.json) together with one or more skills. Each skill functions as a reusable function that the model can invoke during conversations, allowing the AI to perform actions, fetch data, or generate artifacts that go beyond plain text generation.

According to the source code in the openai/plugins repository, every plugin follows a consistent structure: a top-level manifest declaring capabilities, a skills/ directory containing individual skill definitions, and optional app descriptors that handle authentication with external services.

8 OpenAI Plugin Examples from the Repository

Design-to-Code with the Figma Plugin

The Figma plugin converts UI designs into production-ready code and generates design-system rules. Located in plugins/figma/, this plugin points to a Figma-backed app (.app.json) that allows skills to pull frames and components directly from Figma files.

The manifest at plugins/figma/.codex-plugin/plugin.json declares capabilities including "Interactive", "Read", and "Write", with a default prompt to "Inspect a Figma design and implement it in code."

The figma-implement-design skill (defined in plugins/figma/skills/figma-implement-design/SKILL.md) accepts a Figma URL and target language, then returns JSX or TSX source code.

Documentation & Knowledge Capture with Notion

The Notion plugin transforms project specifications into implementation plans and captures meeting notes automatically. According to plugins/notion/.codex-plugin/plugin.json, this plugin uses a Notion-backed app to fetch pages and query databases.

The notion-spec-to-implementation skill parses specification pages and synthesizes structured markdown or task lists, inserting them back into Notion databases. This skill is documented in plugins/notion/skills/notion-spec-to-implementation/SKILL.md.

Database & Backend Management with Supabase

The Supabase plugin executes SQL, manages tables, runs migrations, and audits Row-Level Security policies. As implemented in plugins/supabase/, this plugin bundles an MCP server endpoint that skills call via HTTP to communicate with hosted Postgres instances.

The manifest at plugins/supabase/.codex-plugin/plugin.json declares database management capabilities, while skills like postgres-best-practices (in plugins/supabase/skills/postgres-best-practices/SKILL.md) provide schema analysis and security auditing.

Video Conferencing Automation with Zoom

The Zoom plugin creates meetings, manages participants, and retrieves recordings. Located in plugins/zoom/, this plugin ships an SDK-backed app that invokes the Zoom REST API.

The zoom-create-meeting skill accepts parameters like topic, start time, and duration, returning meeting IDs and join URLs. The skill definition resides in plugins/zoom/skills/zoom-apps-sdk/SKILL.md, while the manifest at plugins/zoom/.codex-plugin/plugin.json configures the Zoom app integration.

Analytics & Product Insights with Mixpanel

The Mixpanel-Headless plugin pulls usage metrics, segments users, and generates custom dashboards. According to plugins/mixpanel-headless/.codex-plugin/plugin.json, this plugin uses a Mixpanel-backed app to query analytics data.

The dashboard-expert skill (defined in plugins/mixpanel-headless/skills/dashboard-expert/SKILL.md) performs data aggregations via the Mixpanel API and returns JSON ready for visualization.

AI-Enabled Code Generation for iOS and Web

The Build-iOS-Apps and Build-Web-Apps plugins scaffold new applications and refactor code snippets. These plugins contain platform-specific skills that call toolchains like xcodebuild or npm.

In plugins/build-ios-apps/.codex-plugin/plugin.json, the manifest declares capabilities for generating SwiftUI views. The build-ios-apps skill (in plugins/build-ios-apps/skills/build-ios-apps/SKILL.md) returns ready-to-compile source files when the model requests new screens or features.

Creative Media Generation

The Google-Slides and Remotion plugins produce slide decks and generate videos from text prompts. These media-focused plugins translate natural-language prompts into slide layouts or video timelines.

The plugins expose assets that can be downloaded or displayed directly, with manifests located at plugins/google-slides/.codex-plugin/plugin.json and plugins/remotion/.codex-plugin/plugin.json.

Enterprise Workflow Automation

The Atlassian-Rovo and Box plugins triage GitHub issues, create Jira tickets, and sync data between SaaS tools. These plugins embed connectors to enterprise services, allowing skills to parse issue descriptions and auto-label them or create corresponding tickets in external systems.

How OpenAI Plugins Work: Architecture Deep Dive

The Manifest File (.codex-plugin/plugin.json)

Every plugin requires a manifest file that declares the plugin name, version, capabilities, and skill locations. For example, the Figma plugin's manifest at plugins/figma/.codex-plugin/plugin.json specifies:

{
  "name": "figma",
  "version": "2.0.9",
  "interface": {
    "displayName": "Figma",
    "capabilities": ["Interactive","Read","Write"],
    "defaultPrompt": [
      "Inspect a Figma design and implement it in code",
      "Create Code Connect templates for my components"
    ],
    "brandColor": "#1ABCFE"
  },
  "skills": "./skills/",
  "apps": "./.app.json"
}

This manifest tells the model which skills are available (./skills/) and what permissions the plugin requires (Interactive, Read, Write).

Skill Structure

Skills live under plugins/<name>/skills/ and contain a SKILL.md file defining the skill's purpose, input schema, and API calls. For instance, the Notion plugin's notion-spec-to-implementation skill explains how specification pages convert into task hierarchies.

Each skill functions as a sandboxed function call that the model can invoke with structured JSON payloads.

App-Backed Integration

Most plugins ship a .app.json file pointing to external services like Figma, Notion, or Supabase. This architecture keeps authentication and rate-limiting isolated from core plugin logic. When the model calls a skill, the request routes through the app descriptor, ensuring secure credential management while the skill handles the business logic.

Code Examples: Invoking OpenAI Plugin Skills

In practice, the model handles the plumbing, but developers can understand the expected payloads. Here are minimal examples showing how to invoke skills from the repository:

Generate UI Code from Figma

{
  "skill": "figma-implement-design",
  "input": {
    "figma_url": "https://www.figma.com/file/abcd1234/MyDesign?node-id=12%3A34",
    "target_language": "tsx"
  }
}

This skill retrieves the specified frame and runs the design-to-code engine, returning JSX/TSX source.

Create Notion Tasks from Specifications

{
  "skill": "notion-spec-to-implementation",
  "input": {
    "page_id": "d1e2f3g4h5i6j7k8",
    "output_database_id": "a9b8c7d6e5f4g3h2"
  }
}

The skill parses the spec page, generates a hierarchy of tasks, and inserts them into the target database.

Query Supabase Table Schemas

{
  "skill": "supabase-fetch-schema",
  "input": {
    "project_id": "proj_12345",
    "table_name": "users"
  }
}

This returns a JSON description of columns, types, and Row-Level Security policies.

Schedule Zoom Meetings

{
  "skill": "zoom-create-meeting",
  "input": {
    "topic": "Project Sync",
    "start_time": "2026-06-15T14:00:00Z",
    "duration_minutes": 30
  }
}

The response contains the meeting join URL and meeting ID.

Summary

OpenAI plugins extend AI models beyond text generation by providing structured, secure access to external services. Key takeaways include:

• OpenAI plugins are self-contained bundles with declarative manifests (.codex-plugin/plugin.json) and reusable skills stored in skills/ directories.
• Skills act as functions that perform specific actions like fetching Figma designs, querying Supabase databases, or creating Zoom meetings.
• App-backed integration isolates authentication via .app.json descriptors, keeping credentials secure while enabling powerful API interactions.
• The repository includes production examples for design-to-code (Figma), documentation (Notion), database management (Supabase), video conferencing (Zoom), analytics (Mixpanel), code generation (Build-iOS-Apps, Build-Web-Apps), media creation (Google-Slides, Remotion), and enterprise automation (Atlassian-Rovo, Box).

Frequently Asked Questions

What is an OpenAI plugin?

An OpenAI plugin is a self-contained software bundle that exposes a declarative manifest and one or more skills, allowing AI models to perform actions, fetch data, or generate artifacts beyond text generation. According to the openai/plugins repository, each plugin consists of a manifest file (.codex-plugin/plugin.json), a skills directory, and optional app descriptors for external service integration.

How do OpenAI plugins authenticate with external services?

OpenAI plugins use app-backed integration via .app.json descriptors that isolate authentication and rate-limiting from core plugin logic. This architecture routes model calls through dedicated app endpoints, ensuring secure credential management while skills handle business logic. For example, the Supabase plugin routes requests through an MCP server endpoint that communicates with hosted Postgres instances.

Can I create custom OpenAI plugins?

Yes. Developers can create custom plugins by following the structural pattern established in the openai/plugins repository: create a manifest file at .codex-plugin/plugin.json declaring capabilities and skill paths, define individual skills in a skills/ directory with SKILL.md files describing inputs and API calls, and optionally include .app.json for external service authentication.

What is the difference between a skill and an app in OpenAI plugins?

A skill is a reusable function defined in SKILL.md files that specifies what action to perform (e.g., figma-implement-design), while an app is the connection layer defined in .app.json that handles authentication and API communication with external services like Figma, Notion, or Supabase. Skills contain the business logic and input schemas, whereas apps manage the secure transport to external APIs.

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