Skip to main content
Use this guide to test an Interchange-powered, customer-branded app in ChatGPT before preparing its public submission. ChatGPT currently labels this developer-mode connection a Plugin.
A developer-mode connection is private test configuration. Its name, icon, and description do not publish an app, change the Interchange MCP server’s identity, or automatically carry into another customer’s submission.

​
Before you start

You need:
  • a ChatGPT account or workspace that permits Developer mode;
  • an Interchange account with access to a buyer or seller account enrolled in the v3 preview that you will demonstrate;
  • an owner-approved app name and short description; and
  • a square PNG icon, ideally 256 x 256 pixels and no larger than the limit displayed by ChatGPT. The current form accepts at most 10 KB.
Use a review or demo account with representative data. Do not record production credentials, access tokens, private customer data, or real campaign spend.

​
1. Add your plugin in Developer mode

  1. In ChatGPT, open Settings → Security and login.
  2. Turn on Developer mode. Availability depends on the ChatGPT account and workspace policy.
  3. Open the ChatGPT Plugins page and select the plus button.
  4. Complete New Plugin with these values:
  1. Review the custom-server warning and select I understand and want to continue only if the endpoint exactly matches your private-label handoff.
  2. Select Create and complete the app’s sign-in flow with a reviewer whose home Interchange account is the account assigned to this private-label app. The hostname is account-bound and refuses a different active account.
  3. Review the tools and metadata ChatGPT discovers from the server.
If ChatGPT cannot create the connection, copy the private-label URL from the handoff again, check that OAuth is selected, and confirm that your workspace allows custom MCP servers. Do not edit the URL path or fall back to the shared Interchange endpoint. The v3 authentication guide explains which Interchange account and permissions the login grants. If Scan Tools reports Access token is not valid for this protected resource after changing the MCP Server URL, disconnect the saved authorization and reconnect before scanning again. ChatGPT discovers the OAuth configuration from the server; no advanced-field overrides are required.

​
2. Verify the connection

Start a new chat, enable the plugin from the tools menu, and ask:
Confirm that the result names the assigned account before demonstrating any workflow. If it does not, reconnect with the dedicated reviewer identity for that account; do not switch a private-label app into another account. Then test the exact prompts you plan to give reviewers:
  • a read that returns useful account data;
  • a representative write that shows the expected confirmation before it runs;
  • a follow-up that reuses an identifier from the prior result; and
  • an unsupported or unsafe request that produces the intended clarification, refusal, or safe fallback.
Use demo fixtures for writes and stop before creating real spend. If you change tool metadata or deploy a server update, refresh the connection and rerun the tests in a new conversation.

​
3. Record the review video

Record one clean end-to-end session while the developer-mode plugin is enabled. The recording should show:
  1. the app name and icon in ChatGPT;
  2. the plugin selected for a new conversation;
  3. get_status confirming the review account;
  4. at least one representative read workflow;
  5. the confirmation and result for a safe demo write, when the app supports writes; and
  6. the expected behavior for one negative test.
Keep the browser URL, app identity, prompts, confirmations, and final results legible. Hide password-manager overlays, credentials, OAuth tokens, personal data, internal admin screens, and unrelated browser tabs. Store the recording in the customer’s approved file-sharing system; do not commit video files to a source repository. The video is part of the submission handoff and a useful reproduction artifact. OpenAI’s portal requirements can change, so check the live form to determine whether to upload the recording, link it, or retain it for reviewer follow-up. For reference, watch the example review video created for the Interchange app.

​
4. Prepare the public submission

Developer-mode branding is not a public listing. The intended handoff is one app-specific submission package rather than a request to assemble each upload by hand. An account admin prepares it on the Branding & distribution Page’s ChatGPT app block (see Create a white-label ChatGPT app for the full walkthrough; the retired Account Settings “Discovery & distribution” tab held these same controls before AI-7434 moved them here):
  1. Review the reusable identity sourced from the published brand profile. Interchange generates a 256 × 256 directory PNG and 48 × 48 composer PNG from the storefront’s brand.json logo and includes them in the package — there is nothing to upload. A missing logo blocks the download itself: the Page and the operation’s error both name the missing brand.json logo as the reason. One-time portal choices are completed in OpenAI rather than duplicated on the Page.
  2. For a customer-owned public origin, create both displayed DNS records: the tenant-specific TXT ownership challenge and the CNAME routing target. The hostname must also have a valid HTTPS certificate. A DNS provider that proxies the CNAME and supplies the certificate is supported: activation verifies a same-host routing proof when public DNS flattens the CNAME record, but that routing proof never replaces the tenant-specific TXT proof. The Interchange first-party app uses its platform-managed hostname and skips CNAME setup.
  3. Paste the OpenAI verification token. The Page displays both the saved token and its public challenge URL. Test public URL (probe_chatgpt_app_verification_token) confirms only that the URL returns that exact token; OpenAI performs domain verification separately.
  4. When the Reviewer sandbox account control appears, choose I want ChatGPT after the listing is Public. Interchange records a bounded review request owned by the current account; the Page shows its requested, provisioning, active, failed, revoked, or expired state. Reviewer buyer and seller credentials are provisioned during operator activation and delivered separately through an approved secret channel. They are never displayed in the Page or returned to the customer-facing tool. Choose Revoke reviewer access as soon as review ends. If status is temporarily unavailable, the Page disables both actions until a refresh can safely determine the current grant.
  5. Download the OpenAI submission package.
The bundle contains:
  • chatgpt-app-submission.json with the current tool annotations, all three required annotation justifications, and test prompts for the private-label app;
  • the generated 256 x 256 directory icon and 48 x 48 composer icon, when a usable brand logo was available at publication time;
  • interchange-buyer-skills.zip for buyer apps as a manual fallback containing one upload-ready directory of the same account-readiness, campaign-setup, and campaign-management skills advertised by the V3 server;
  • readiness-report.json, which records a stable snapshot ID, every portal field, its source, readiness, blockers, and regeneration rules; and
  • one consolidated README.md with the complete field map, prompt and locale review, release copy, screenshot plan, and video storyboard.
The outer ZIP intentionally contains no duplicate listing, CSP, annotation, prompt, checklist, or release-note files. Those details live either in the import JSON, the readiness report, or the README. The generated chatgpt-app-submission.json uses the portal-required $schema value https://developers.openai.com/apps-sdk/schemas/chatgpt-app-submission.v1.json. The package includes justifications only for tools exposed by its MCP endpoint. Account-bound app hostnames omit switch_account; the shared Interchange endpoint includes it because account switching remains available there. After importing the file, review the portal’s imported, skipped, missing, and mismatched counts before submitting the app for review. If OpenAI rejects that value, do not hand-edit the file. Send Interchange support the exact validation error; after support confirms that an updated release is deployed, download a fresh submission package. OpenAI performs the live tool and skill scans in the submission portal. The V3 MCP server advertises OpenAI’s bounded MCP Skills extension, so Scan tools automatically imports the three canonical buyer skills when the authenticated account is a Buyer Account. Seller Account scans do not receive buyer skills. Review the imported skills immediately before submission. The imported skills are submission-time snapshots, not live runtime content. Run Scan tools again after Interchange publishes a skill update. The buyer ZIP contains interchange-buyer-skills.zip only as a same-content fallback for manual upload when the scan cannot complete; do not upload it when the scan succeeds. Starter prompts remain a portal choice because OpenAI’s submission JSON schema does not currently define them. A storefront with no logo in brand.json cannot download the package — add a logo there first. Once a logo exists, the icons regenerate automatically the next time you publish; there is no manual PNG to save. The verification token is public at the challenge URL and visible on the admin-only Branding & distribution Page, but deliberately excluded from the ZIP, logs, and reviewer handoff. Never reuse another customer’s bundle or replace its exact private-label MCP URL with the shared Interchange endpoint. The publisher still completes the requirements that cannot safely be generated:
  • select the verified business or individual identity that will publish the app;
  • confirm Apps Management write access for each submitter;
  • confirm the domain-verification challenge published from the Branding & distribution Page before pressing Verify in OpenAI;
  • confirm that the account-owned reviewer request was activated against the dedicated, least-privileged synthetic no-spend reviewer pair. Deliver its one-time credentials only through the submission portal, ensure they work without MFA, SMS, email confirmation, or private-network access, and revoke the grant when review ends;
  • approve country availability, policy attestations, and the generated listing and release copy; and
  • approve the final review video and its sharing location.
Follow OpenAI’s current submission guide when completing the portal. Scan the production server again immediately before submission and review every discovered tool, annotation, skill, domain, and validation result.

​
5. Manage review and publication

Submitting starts OpenAI’s review; it does not publish the app. Keep a release record in your approved system with the bundle’s snapshot ID, source revision, generation and submission times, OpenAI draft or version reference, publisher owner, and current review state. Keep the exact outer ZIP in approved, access-controlled release storage. Do not put reviewer credentials, OAuth tokens, domain-verification tokens, or private customer data in that record, the ZIP, or a support ticket, and do not attach the ZIP to an unrestricted ticket. While review is active, keep the dedicated reviewer identity, synthetic no-spend fixtures, production MCP endpoint, domain challenge, tool metadata, and scanned skills available. Send Interchange support any reviewer feedback verbatim with the snapshot ID. Do not regenerate or hand-edit the submitted files unless the feedback requires a new version. After approval, test the approved snapshot once more, then use the OpenAI portal’s Publish action. Verify directory discovery, installation, OAuth, get_status, and one safe workflow, and monitor the launch for 24 hours. Rotate or revoke the dedicated reviewer credentials when OpenAI no longer needs them. After rejection, preserve the exact feedback and snapshot ID. Correct the canonical configuration or Interchange source, download a fresh bundle, replace the affected files, scan tools and skills again, rerun all five positive and three negative cases, update the release notes, and submit a new version. Published metadata and imported skills are reviewed snapshots; later server-side skill changes do not update the published app automatically.

​
Get conversational setup help

Give an MCP-capable agent the public, versioned Publish an OpenAI App skill. Authenticated Seller Accounts also advertise it through the MCP Skills extension, so Murph and compatible clients can load the same workflow without copying this guide into a prompt. Distribution uses the existing V3 noun surface rather than adding provider-specific tools:
  • get({ kind: "distribution" }) returns the configured public hostname, CNAME target, ownership record, hostname status, MCP URL, and OpenAI challenge status. An active customer CNAME is the server-owned verification result; the agent does not claim to test an OpenAI submission.
  • The same read returns a bounded channels.chatgpt summary: whether the listing is ready to submit, how many blocking items remain, this channel’s own hostname and verification status, whether the submission bundle is current and the listing approved, and one next-step line. It never claims the app is live in ChatGPT — OpenAI’s review and publish decision happens entirely on their portal — so it reports platform-side readiness only.
  • save_seller({ distribution: { openaiChallengeToken: "..." } }) publishes the portal-provided challenge token. Replacing or removing a current token requires the corresponding confirmation field.
Both operations are Seller-account-admin only. Reviewer access, portal scans, screenshots, and video remain manual work described by the submission package.

​
Use the native OpenAI plugin package

The Interchange repository also contains a universal OpenAI plugin package for the shared production endpoint. It includes the approved icons, the same three canonical buyer skills, and a direct HTTPS MCP mapping to https://api.interchange.io/mcp/v3. Installation starts OAuth; API keys and provider credentials never belong in the manifest or prompts. The plugin manifest, marketplace entry, skill bytes, and release notes are versioned together. Directory screenshots and any registered OpenAI app identifier remain publication inputs controlled by the Interchange publication owner; the package does not invent them. Revalidate and re-record those assets for each visible release.

​
Understand the white-label boundary

Interchange does not infer ChatGPT branding or publisher details from an AdCP partner registration, seller profile, or MCP connection. In particular:
  • adding a partner AdCP endpoint does not turn it into a ChatGPT MCP endpoint;
  • a customer’s logo and listing copy must be uploaded in that customer’s developer-mode configuration and public submission;
  • the verified publisher identity, public policies, and support details must match the organization submitting the app. When the app uses Interchange, the customer’s privacy policy must also disclose the relevant Interchange data handling; and
  • a customer-owned MCP host requires its own production endpoint, OAuth metadata, tools, annotations, UI resources, security review, and submission.
Do not use the shared https://api.interchange.io/mcp/v3 endpoint for a private-label Developer-mode connection or public submission. OpenAI verifies one exact token at the host-level /.well-known/openai-apps-challenge path; changing only the MCP URL path cannot separate multiple app challenges on the same host. A customer-owned public app therefore needs either a dedicated, customer-controlled hostname that serves its MCP, OAuth, and verification challenge, or an explicit arrangement approved by both Interchange and OpenAI. Control of an Interchange account does not grant control of the api.interchange.io domain.