OpenAI dropped two-way MCP. Make it wake ChatGPT when something changes in your work.

Claude Code or Codex, Python 3, cloudflared, and a ChatGPT account that can add a custom MCP server. OpenAI names no plans: "Account and workspace policies apply to adding and using custom MCP servers." Tested with Claude Code on Windows. Codex, Mac and Linux are untested.

1. 01

   Decide your event and your task before you build anything. An event is one thing that happens in your work and is worth being woken for: a failed build or deploy, a new order or payment, a new form or support entry, a new issue or comment. The task is what ChatGPT does when the event arrives. In the reel the event is bug_report.created and the task is to draft a fix plan.

   Your part: write both down as one sentence, such as "When a deploy fails, summarize the error and draft a fix plan." Start with a task that drafts or summarizes. OpenAI's docs say events can arrive out of order and that ChatGPT can group several into one run, so pick a task that is safe to repeat.

2. 02

   Make an empty folder, start Claude Code or Codex in it, and paste the prompt. It asks you three questions, proposes an event name and a payload, and waits for your yes. Then it writes one small Python MCP server: one read-only tool, your event, the three event methods (events/list, events/subscribe, events/unsubscribe), webhook signing, a fire command, and a self-test that plays ChatGPT's part on your own computer.

   Paste into Claude Code or Codex

   Copy prompt

   Build me a small MCP server that uses MCP Events in ChatGPT: ChatGPT subscribes to one event from my own work, and my server pushes that event into a ChatGPT Work chat with a signed webhook.
   
   START BY ASKING ME THREE QUESTIONS, then wait for my answers
   1. What in my work should wake ChatGPT? Offer these as examples: a failed build or deploy, a new order or payment, a new form or support entry, a new issue or comment, a new bug report (bug_report.created).
   2. What should ChatGPT do when it arrives? For example: draft a fix plan, summarize it, draft a reply for me to review.
   3. Where does that event come from today: an app, a script, a CI job, a form, a folder?
   From my answers, propose an event name in the form thing.happened (for example build.failed or bug_report.created), a payload of three to five short fields, and one read-only tool that lists recent items. Show me the proposal and wait for my yes before you write code.
   
   I have not built or hosted an MCP server before. Before each stage, tell me in one or two plain sentences what you are about to do and why.
   
   READ THESE FIRST. The spec is a draft, so follow the pages over anything you remember:
   - https://developers.openai.com/plugins/build/mcp-events
   - https://developers.openai.com/plugins/deploy/connect-chatgpt.md
   - https://developers.openai.com/plugins/quickstart.md
   
   CHECK
   - Run python --version (or py -3 --version) and cloudflared --version. If one is missing, stop and give me the install command for my system.
   
   BUILD
   - In this folder, one server file plus one self-test file. Use only the Python standard library and hand-write the JSON-RPC over HTTP POST at /mcp (http.server worked for the guide's author). Do not install an MCP SDK.
   - Use streamable HTTP with plain JSON responses at /mcp. No Server-Sent Events: Cloudflare Quick Tunnels do not support them.
   - Protocol version 2026-07-28. Answer server/discover with supportedVersions ["2026-07-28"] and capabilities {"tools": {}, "events": {}}.
   - Also answer the older initialize handshake (echo the client's protocolVersion), ping, tools/list and tools/call. Reply 202 to notifications (requests with no id). Put the resultType field the OpenAI page shows in every result.
   - One read-only tool: the list tool we agreed. emit appends each event to a gitignored file and the list tool reads that file, so the list is the same from every process.
   - One event: the one we agreed, with a name, a description, delivery ["webhook"], an inputSchema that takes no arguments, and a payloadSchema for the fields we agreed. The payload carries facts. Never put instructions to the model in it.
   - events/list returns that event.
   - events/subscribe:
     - accept only delivery mode "webhook"
     - require an https callback URL that resolves to a public address
     - require a secret of the form whsec_ + base64 that decodes to 24 to 64 bytes
     - POST a signed {"type": "verification", "challenge": "<random>"} to the callback, with its own unique webhook-id, and store the subscription only if a 2xx comes back echoing the same challenge (constant-time compare). On failure return JSON-RPC error -32015.
     - same callback URL + event + arguments gives the same subscription id, so a repeat call updates it
     - return {id, refreshBefore, cursor: null, truncated: false} with a 24 hour lifetime
   - events/unsubscribe removes the subscription and succeeds even if it is already gone.
   - Store subscriptions in a file so they survive a restart. That file holds signing secrets: gitignore it and never print a secret. If a delivery comes back 410, delete that subscription.
   - Sign with Standard Webhooks. Headers: Content-Type application/json, webhook-id, webhook-timestamp (Unix seconds), webhook-signature = "v1," + base64(HMAC-SHA256(key, "<webhook-id>.<timestamp>.<body>")), X-MCP-Subscription-Id. The key is the base64-decoded part after whsec_. Serialize the body once and send those exact bytes. 10 second timeout, no redirects (urllib follows them, so use http.client), body no larger than 256 KiB.
   - One function, emit, that takes the payload fields, builds {eventId, name, timestamp, data, cursor: null} with a fresh eventId (webhook-id equals eventId, timestamp is ISO 8601 with a timezone), and sends it to every live subscription (one whose refreshBefore has not passed). Everything that fires an event calls this one function.
   - A fire command for testing, for example: python server.py fire "Checkout button does nothing on mobile Safari". It takes the main text field as its argument, fills the other fields from flags or defaults, calls emit, and prints the subscriber count and the HTTP status for each.
   - A second listener on 127.0.0.1:8788, which the tunnel never exposes, with one route: POST /emit with a JSON body calls emit. My own app or script will use it later. /emit accepts only Content-Type application/json and an X-Emit-Token header, compared in constant time with a gitignored token file that the server creates if it is missing. Reject anything else with 403, so a web page open in my browser cannot fire events.
   - Log every incoming method with its MCP-Protocol-Version header, and log the client info on server/discover and initialize. I will need that log to debug the ChatGPT side.
   - Self-test: a fake receiver that subscribes over HTTP, echoes the challenge and verifies the signature on a delivered event. Compare header names case-insensitively. The self-test starts its own copy of the server on other ports (for /mcp and /emit), with its own temporary data folder and a test-only flag that allows http://127.0.0.1 callbacks, then stops it. The server refuses that flag on port 8787 or with the real data folder.
   
   RUN
   - Run the self-test, then start the server on 127.0.0.1:8787. Handle requests on threads (ThreadingHTTPServer, with allow_reuse_address off so a second copy cannot share the port), so one slow callback does not block the next request.
   - It needs a public HTTPS URL. Before the tunnel opens, tell me plainly that anyone who learns that URL can call the tool and subscribe, so the payload must hold no secrets, private paths or customer data. The command: cloudflared tunnel --url http://127.0.0.1:8787
   - If your permissions or sandbox block the tunnel, stop and give me the command. In Claude Code I will run it with the ! prefix in this session. In Codex I will run it in a second terminal and paste back the URL.
   - Once the tunnel is up, call events/list through the public URL and show me the result.
   - Do not register this server in your own MCP settings (Claude Code's MCP config, Codex's config.toml). In the author's test a plain MCP connection opened with initialize on an older protocol and fetched tools only. ChatGPT asked for events once the server was added as a plugin.
   
   THEN PRINT THESE STEPS FOR ME, with my real URL, event name and task filled in
   1. chatgpt.com/plugins, plus button, Add custom MCP server. A name and a description, Server URL set to the public URL ending in /mcp, Authentication set to No authentication (this test server has no login). Read the warning, select I understand and want to continue, then Create as a plugin.
   2. On the plugin page, check my event is listed beside the tool. If it is missing, select Refresh.
   3. Open the plugin and select the plus button to install it.
   4. On the ChatGPT home page switch Chat to Work (desktop app: Work with Cloud selected). New chat, type @, pick the plugin, and send: Subscribe to the <event name> event. When one arrives, <my task>.
   5. Tell you when ChatGPT says it is monitoring.
   
   WHEN I SAY I HAVE SUBSCRIBED
   - Confirm the log shows events/subscribe on 2026-07-28 and one stored subscription before firing anything. If there is none, say so and do not fire.
   - Fire one event and report the status. Use different text each time. ChatGPT flagged identical text as a duplicate in the author's test.
   - A 2xx means ChatGPT received it. ChatGPT processes the event asynchronously, and in the author's test the chat message took about five minutes. Do not fire again because the chat is quiet.
   - If the tunnel restarts, the URL changes: tell me to update the plugin's Server URL and select Refresh.
   
   THEN SHOW ME HOW MY REAL SOURCE WOULD FIRE IT
   - From my answer to question 3, write the smallest hook that calls emit when the real thing happens: a few lines in my local script that run the fire command by absolute path and log if the hook itself fails, or a POST to the local /emit route from an app on this computer. If my source runs on another machine (hosted CI, a SaaS form, a store), say so, and do not expose /emit. Offer a small local watcher that polls that source and calls emit.
   - Show me the hook. Do not install it or touch my real systems until I say yes. When I say yes, install it, then ask me to make the real thing happen once and watch the log with me.
   - Check that the task ChatGPT runs cannot cause the same event again. If it could, tell me how the loop would happen.
   
   WHEN I SAY I AM DONE
   - Stop the server, remind me to stop the tunnel, and remind me to tell ChatGPT to stop monitoring.
   
   Skip OAuth, retries and a database for this first run. Mark each shortcut with a one-line comment that says what a server I keep would do.

   Your part: answer the questions with your real event, approve the file and run commands, and check that the self-test passes before you go on. We ran the bug report build with ChatGPT in Claude Code. The prompt on this page was then run once more on our computer, without ChatGPT, for a failed backup script: the server built and its self-test passed. Codex is untested. Adding the server to your agent's own MCP settings does nothing for ChatGPT, so skip it.

3. 03

   Put the server on a public HTTPS URL. ChatGPT runs on the internet and your server runs on your computer, so ChatGPT cannot reach it yet. A tunnel gives your computer a temporary public address. A Cloudflare Quick Tunnel needs no account and no domain, and Cloudflare offers it for testing and development.

   Run this yourself if the agent cannot

   Copy prompt

   cloudflared tunnel --url http://127.0.0.1:8787

   Your part: if the agent is blocked from opening the tunnel, run the command yourself. In Claude Code, type ! and then the command, which runs it in your session. Auto mode refused the tunnel in our test. In Codex, run it in a second terminal and paste the URL back. Copy the https address that ends in trycloudflare.com and add /mcp to the end. The address changes every time the tunnel restarts. Only cloudflared was tested.

4. 04

   Add the server to ChatGPT as a plugin. Go to chatgpt.com/plugins, select the plus button, then Add custom MCP server. Give it a name and a description, paste your address into Server URL with /mcp on the end, and set Authentication to No authentication. Read the risk warning, select I understand and want to continue, then Create as a plugin. Open the plugin and select the plus button to install it. ChatGPT calls this a plugin. The reel says connector.

   Add custom MCP server

   Your part: check that the plugin page lists your event beside the tool. If you see the tool alone, select Refresh. No authentication is how our test ran on 6 October 2026, and ChatGPT's form accepted it. Treat that as a short test setting: while the tunnel is open, anyone who has the address can reach the server. A server you keep needs a login.

5. 05

   Subscribe in a ChatGPT Work chat. On the ChatGPT home page, switch Chat to Work. Start a new chat, type @ to pick your plugin, and send one sentence that names the event and gives the task. OpenAI's docs list Work chats on the web, Work chats in the desktop app with Cloud selected, and dots.

   Send in the Work chat, with your own event and task

   Copy prompt

   Subscribe to the <your event name> event. When one arrives, <your task>.

   Your part: wait until ChatGPT says it is monitoring, then tell your agent. Ask it to confirm that the server log shows events/subscribe on 2026-07-28 and one stored subscription. The reel's sentence was "Subscribe to the bug_report.created event. When one arrives, draft a fix plan." If ChatGPT says the plugin "exposes only" its tool, the log will show 2025-06-18 and no server/discover: remove it and add it again at chatgpt.com/plugins with Create as a plugin. If ChatGPT says it has nothing to subscribe with, check that you are in a Work chat and that your sentence names the event.

6. 06

   Fire a test event and wait. Ask your agent to fire one, or run the command it printed for you. The output should show 1 subscriber and a 200. Then watch the Work chat: the event arrives and ChatGPT does your task. Once that works, tell your agent yes on the hook, and make the real thing happen once: run the script, submit the form, save the order. That arrival is the finish line.

   The reel's example. Run the command your agent printed

   Copy prompt

   python server.py fire "Checkout button does nothing on mobile Safari"

   Your part: be patient. A 200 means ChatGPT received the event, and in our test the message reached the chat about five minutes later. A quiet chat is no reason to fire again. Change the text on each test, because ChatGPT flagged identical text as a duplicate. When you are done, tell ChatGPT to stop monitoring, then stop the tunnel and the server.