> ## Documentation Index
> Fetch the complete documentation index at: https://docs.staging.alpic.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# From code to ChatGPT/Claude Plugin

> Take your plugin from source code to a published listing in ChatGPT and Claude - and keep improving it without disrupting the live experience.

## Steps

Publishing in ChatGPT and Claude means submitting a specific app version for review. Once approved, that version is served to users, and experience changes require resubmission. This playbook walks through the Alpic process and the key checks for passing review.

<Steps>
  <Step title="Create your account" stepNumber={0}>
    Go to [app.alpic.ai](https://app.alpic.ai), click on **Sign in with GitHub** and authorize **Alpic AI** to access
    your GitHub account.
  </Step>

  <Step title="Deploy" stepNumber={1}>
    Deploy your app with zero config. [Views and assets](/build-deploy/assets),
    [environments](/build-deploy/environments), [OAuth](/secure/auth/overview) and [custom
    domains](/distribution/domains) are built in, on SOC 2 Type II infrastructure.
    [(Details)](#1-deploy-to-a-dedicated-environment)
  </Step>

  <Step title="Test like a user" stepNumber={2}>
    Try your app in the [Playground](/testing/playground), a production-like host with a shareable link, before it is
    listed anywhere. Use{" "}

    <a href="/cli/tunnel" target="_blank" rel="noopener">
      Tunnel
    </a>

    {" "}

    to test local changes. [(Details)](#2-test-like-a-user)
  </Step>

  <Step title="Audit" stepNumber={3}>
    Run [Beacon](/testing/beacon) to check protocol, tool metadata, view rendering and CSP against the ChatGPT and
    Claude directory rules to ensure successful review. [(Details)](#3-audit-with-beacon)
  </Step>

  <Step title="Submit" stepNumber={4}>
    The [submission helper](/distribution/submissions) pre-fills both directories' forms and test cases from your
    deployed server. [(Details)](#4-prepare-the-package-and-submit)
  </Step>

  <Step title="Ship updates safely" stepNumber={5}>
    Follow the [versioning rules](/distribution/versioning) so an update never breaks the approved version.
    [(Details)](#5-ship-updates-safely)
  </Step>

  <Step title="Observe and grow" stepNumber={6}>
    [Analytics](/analytics/overview) show sessions, clients, tool calls, errors and latency, and [User
    Insights](/user-insights/user-intents) shows what people ask your app for. [(Details)](#6-observe-and-grow)
  </Step>
</Steps>

## Details

## 1. Deploy to a dedicated environment

In the [Alpic dashboard](https://app.alpic.ai), click **New Project**, then start from a starter template, import your own Git repository, or clone a ready-to-use example project. The first time, Alpic asks you to connect your GitHub account, so it can create or read the repository and redeploy on every push.

<Tip>
  [Skybridge](https://skybridge.tech) is Alpic's open-source TypeScript framework for MCP Apps. You write your views in
  React, get end-to-end type safety between tools and views, and develop with hot reload and devtools. The same app runs
  in ChatGPT, Claude and any client that supports MCP Apps, and Alpic deploys it with no configuration.
</Tip>

Prefer another framework? Alpic also detects and builds servers written with the official TypeScript and Python MCP SDKs, FastMCP and xmcp. See [Builds](/build-deploy/builds) for how detection works.

## 2. Test like a user

Every Alpic environment has a [Playground](/testing/playground) at `/try`, a full MCP host with a preconfigured model. It renders your views the way ChatGPT and Claude do.

* Add [example prompts](/cli/playground-example-prompt-add) to the Playground. They show testers what the app can do, and they make good test cases for your submission.
* Check each view in every display mode your app uses: inline, picture-in-picture and fullscreen.
* Share the `/try` link with teammates and beta testers before any directory lists the app.
* To test changes before deploying them, run [`alpic tunnel`](/cli/tunnel) and open `/try` on your tunnel URL.

## 3. Audit with Beacon

[Beacon](/testing/beacon) checks your server against the same specifications and platform rules the directories apply in review. It also launches your app in a real ChatGPT and Claude conversation and checks that each view renders.

Run it from the dashboard, or from your terminal or CI:

```bash theme={null}
alpic audit --url https://mcp.example.com/v1/mcp
```

Fix all **errors** before you submit; the directories reject apps that fail them. The checks that most often block a listing are:

* **Tool annotations.** Every tool declares `readOnlyHint`, `destructiveHint` and `openWorldHint`.
* **CSP and domains.** Your widget is JavaScript running inside an iframe inside ChatGPT. ChatGPT can't trust arbitrary code, so it sandboxes it. CSP - Content Security Policy - is how you tell the sandbox what your code legitimately needs. Make sure you declare the most critical domains:
  * `connectDomains`: every domain your view fetches data from. Without it, requests are blocked.
  * `resourceDomains`: every domain serving static assets such as scripts, images and fonts. Without it, the view renders broken.
  * `redirectDomains`: every external site your app sends users to. Without it, ChatGPT warns users that they are leaving ChatGPT.
* **Edge-case input handling.** Reviewers don’t always test edge cases by hand, but they do run automated checks. Once your app is live, every weird input will eventually hit your tools, so this shapes your users’ experience too. Make sure you handle cases like empty strings (`""`), `null` values; dates in the past (`2020-05`), out-of-range numbers (`-50`) as well as unicode oddities, such as emoji or accented characters (`France 🇫🇷`)

<Info>Beacon and the submission helper don't support OAuth-protected servers yet.</Info>

## 4. Prepare the package and submit

### Set up the version you will submit

Before you create the submission:

* **Create an environment per submitted version.** Name it after the release (`v1`, `v2`) so it is obvious which environment backs which listing. Directories cache part of your server at submission time, so a dedicated environment keeps that version stable while you keep developing elsewhere. See [Recommended release workflow](/distribution/versioning#recommended-release-workflow).
* **Decide on your domain now.** ChatGPT expects the same domain across versions. If you plan more than one version, put a [custom domain](/distribution/domains) in front and route each version with a path prefix, for example `https://mcp.example.com/v1`.
* **Name your view assets deterministically.** With stable asset names, you can fix a view after approval by redeploying, without a new submission. See [Asset naming strategy](/distribution/versioning#asset-naming-strategy).
* **Protect it if needed.** Add [authentication](/secure/auth/overview) or [IP allowlisting](/secure/ip-whitelisting) before you share the URL.

Open **Submissions** in your project and create one submission per directory. The [submission helper](/distribution/submissions) reads your deployed server, fills in what it can, drafts the narrative fields and runs Beacon again.

Before you start, have these ready:

| You need | ChatGPT | Claude |
| - | - | - |
| Account | A verified individual or organization on the OpenAI platform | A Team or Enterprise organization with directory management access |
| Links | Privacy policy, terms of service, company website, support channel | Same |
| Assets | Logo and screenshots, uploaded in the helper | Same |

### Submit and respond to review

When the submission shows **Ready to export**, open the handoff for its directory:

* **ChatGPT:** upload the generated submission file at [platform.openai.com/plugins](https://platform.openai.com/plugins), then paste the remaining fields.
* **Claude:** open the [directory submission form](https://claude.ai/admin-settings/directory/submissions/new) and copy each value from the handoff, in the same order.

If a reviewer asks for changes, fix them in the same environment and re-run Beacon before you resubmit. Keep the submitted environment stable while the review is open.

## 5. Ship updates safely

Once approved, ChatGPT and Claude cache your `tools/list` response and, for MCP Apps, your views' entrypoint HTML. Calls still reach your latest deployment. A change that doesn't match the cached schema can break every call to a tool.

* **Safe to ship with a redeploy:** handler logic, and view assets with stable names.
* **Needs a new submission:** new tools, new or changed parameters, new views and changed entrypoint HTML.
* **Never** add a required parameter or remove a tool before the new version is approved.

The [versioning guide](/distribution/versioning) lists the safe migration path for each operation.

## 6. Observe and grow

After launch, the dashboard shows how the app is really used:

* [Analytics](/analytics/overview): sessions by client, tool calls, errors and latency.
* [Telemetry export](/telemetry/traces-export): send logs, metrics and traces to your OTEL stack.
* [User Intents](/user-insights/user-intents): what people asked for when they called each tool.
* [User Feedback](/user-insights/user-feedbacks): what the model and users said about the answers.

Use them to plan the next version, then start again from step 1 with a new environment.

<div style={{ height: "32px" }} />

<Tip>
  Want Alpic to build the app for you? [Alpic Studio](https://alpic.ai/solutions/build/studio) designs, builds and
  submits MCP Apps, and your team owns the result.
</Tip>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.