Resources · 20 Nov 2026

Claude blocked the web page ChatGPT loaded through MCP Apps

ChatGPT and Claude both show interfaces through MCP Apps, and each decides for itself whether a page from your own site may load in one. When we ran one test server in both on 20 November 2026, ChatGPT framed our page and kept a session inside it in Chrome but not in its iPhone app, and Claude left the page out.

Connect Clawnify

One standard behind the interfaces in ChatGPT and Claude

MCP Apps lets an MCP server send back an interface with its answer, a small web page the assistant shows inside the conversation. It's an open standard, an official extension to the Model Context Protocol published as SEP-1865 and marked stable on 26 January 2026. ChatGPT's documentation calls the result a plugin with UI. On Claude's connector directory it's an interactive connector.

The mechanics fit in four lines.

  • A tool on your server names a page, an HTML document at a ui:// address.
  • The host fetches that page and renders it in a sandboxed iframe on an origin of its own. The spec calls the page a view.
  • View and host talk over postMessage. The view can call your server's tools, ask for fullscreen, open a link in the browser and send a message into the chat.
  • A tool can be marked app-only. The view can call it, and the host has to keep it out of the model's tool list.

Both big assistants implement it. OpenAI's page on adding UI says ChatGPT implements the open MCP Apps standard, and the project's README lists ChatGPT, Claude, VS Code, Goose and Postman among its clients. In our test one server answered ChatGPT and Claude alike.

The standard doesn't settle what a page may do once it's there. The sandbox has to allow scripts and same-origin access, and the spec stops at those two. Forms, dialogs, pop-ups and downloads aren't mentioned. A page from another site, your own app for instance, loads inside the view only if the resource declares its origin, and a host "MAY further restrict but MUST NOT allow undeclared domains". So whether the app you already built can open inside the chat is each host's call.

We had a reason to ask. We build and host business apps, and people already read and update their apps' data from ChatGPT and Claude through our connector. We wanted to know if the app itself could open there, so on 20 November 2026 we ran one test server in both.

The same test server gave opposite answers in the two hosts

The test server has three tools and one view. The view asks an app-only tool for a single-use ticket, frames a test page served from the server's own domain, and hands that page the ticket. The page then tries what an ordinary web app does all day. It submits a form, exchanges the ticket for a session cookie, opens a confirm dialog, a pop-up, a new-tab link and a download, and copies text to the clipboard.

We added it to Claude as a custom connector and to ChatGPT as a custom MCP server from its Plugins page, with no sign-in on either, and asked each assistant to open it. The browser was Chrome 157 on a Mac. Later the same day we ran it again in the ChatGPT and Claude apps on an iPhone, signed in to the same accounts.

CheckChatGPT, ChromeChatGPT, iPhone appClaude, both
The view rendersyesyesyes
Our page loads inside the viewyesyesblocked
A form submits in our pageyesyesnever loaded
Sign-in ticketexchanged, reuse refusedexchanged, reuse refusedissued, nowhere to send it
Session cookie comes backyesno cookie at allnever loaded
Confirm dialognone, returns falsenone, returns falsenever loaded
Pop-upnothing opensnothing opensnever loaded
New-tab linknothing opensnothing opensnever loaded
Download linknothing savednothing happensnever loaded
Copy to clipboardrefusedworkednever loaded
Fullscreenyesyesyes
Link outopens a tab at onceasks, then an in-app browserasks, then opens

Read the ChatGPT columns with their limits in mind. This is one account per host, on connectors nobody has reviewed, and a plugin that's been through OpenAI's review may get a different sandbox than one added by hand. We haven't run Safari on a Mac yet. Claude answered the same on the iPhone as in Chrome, except that its link out hands the page to Safari.

One page, three frames deep, in two hosts ChatGPT Chat page chatgpt.com Your view web-sandbox.oaiusercontent.com Your site loads, forms submit The sandbox allows scripts, same-origin and forms. Dialogs, pop-ups and downloads are off. Claude Chat page claude.ai Your view a host on claudemcpcontent.com Your site left out, blocked Ours was refused. A Verified directory listing has to name the site's origin. From our run on 20 November 2026 in desktop Chrome, with connectors we added by hand.

Claude left our page out and said why in the console

In Claude the view opened, ran its own checks and got its ticket. Where our page should have been, Chrome drew its blocked-page icon.

The test view inside Claude, labelled Unverified. Its report shows the view running on a host under claudemcpcontent.com with claude.ai above it, a form that submits and working local storage. Below, a grey area with the browser's blocked-page icon where the framed page should be.

Our test view in Claude on 20 November 2026. The grey area is where the framed page should have loaded.

The reason was in the browser console, written by Claude's own host code:

Not among the sites that Claude allows this connector to show: [our server's address]. Declare only sites the connector is allowed to show; for a connector in the Claude directory, ask for the site to be added to its listing.

The address it refused was the MCP server's own. In Claude, serving the page from the same domain as the server buys you nothing. Anthropic's embedded sites page sets the rule by the kind of connector, in these words.

ConnectorCan its view show your site
Directory, Verified listing"Only when the listing allows the site's origin"
Directory, Community listing"Claude blocks the origin"
Custom connector"Only after the user allows the origin in a conversation"
Local server"Claude blocks the origin"

The custom connector row carries a condition, in the page's words: "Available to a limited set of organizations, and not in every conversation." Claude never asked us to allow the origin, and the view opened without the site, which is the outcome the page describes where embedded sites aren't available to an account.

A view doesn't have to find this out by failing. When it starts, the host tells it what it was granted, and the spec has a field for it, described as "CSP domains approved by the host". Claude reported an empty list of frame domains. ChatGPT's had our origin on it. So one view can serve both hosts. It frames the app when your origin is on the list and shows a button that opens the app in a browser tab when it isn't. All four hosts we tried, ChatGPT and Claude in Chrome and on the iPhone, said at start-up that they can open links, which is all the button needs. If we were shipping this tomorrow we'd build the button first, because it's the one path that worked in both.

Reading that list takes one more step when a view frames more than one site. A view that opens many apps, each on its own subdomain, can't name them all in advance, so it declares a wildcard. We ran the test again in ChatGPT with a pattern covering every subdomain of the test server's domain in place of its exact address. Our page loaded, and the list the host sent back held the pattern, not the address it had matched. So the view has to match the pattern itself before it decides to frame.

In ChatGPT our page loaded with dialogs, pop-ups and downloads switched off

OpenAI allows what Claude refused. Its page on adding UI says plugins with UI can embed pages "from their MCP server's own registrable domain, including full existing editors and admin interfaces". It also asks for a written justification when you submit, and warns that "Iframe use can require additional review or escalation". Our page loaded on the first try, and a form in it submitted from script and from a real click.

The OpenAI pages we read, the one on adding UI and the plugin reference, don't state the sandbox around the view. We read it off the page:

sandbox="allow-scripts allow-same-origin allow-forms"

A page framed inside the view inherits that sandbox, so it gets those three permissions and no others. Everything that failed in our page follows from what's missing.

Your app doesWhat happenedWhat to use
confirm()no dialog, false in 0 msa dialog built into the page
window.openreturned nullthe host's open-link request
A new-tab linknothing openedthe host's open-link request
A download linknothing saveda link out to a browser tab
Copy to clipboardrefused in Chrome, see belowtext the person can select
A formsubmittednothing to change

The copy result needs a caveat. Our Chrome tab was in the background while the test ran, and that alone can make Chrome refuse a clipboard write. In the ChatGPT iPhone app, with the page in front, the same copy worked, so the refusal was probably the background tab and not the host.

Most of these fail where someone will notice. A button that should open a tab opens nothing. The quiet one is confirm(), which came back false at once with no dialog on screen, so a delete button behind an "Are you sure?" check does nothing and reports nothing. We searched our own open-source app templates the same day. Of 55, 16 call the browser's confirm() for guards like "Delete this board?", and 36 open a pop-up, a new tab or a download somewhere.

The framed test page inside ChatGPT. Ticks beside: a form submits by script and by tap, ticket exchanged for a session, the same ticket refused the second time, partitioned cookie comes back, SameSite=None cookie comes back, local storage works. Crosses beside: SameSite=Lax cookie, confirm shows a dialog, window.open opens, copy works.

The framed test page inside ChatGPT on 20 November 2026, after we pressed its buttons.

Anthropic documents the same losses for sites embedded in Claude. Its embedded sites page says pop-ups and new-tab links don't open and a link to a file doesn't download. It says "confirm() returns false. Build dialogs into the page", and that a site can still "submit forms to its own origin". What we measured in ChatGPT matches that list line for line.

Sign-in inside the frame took a single-use ticket and a partitioned cookie

Neither host hands a framed page a session. The person signed in to your connector a minute ago, and the app inside the frame still has no idea who they are. Anthropic's page is blunt about it: "Claude passes no session to the site, and a call to document.requestStorageAccess() is rejected." The same page describes a handoff that gets around this, and nothing in the handoff is specific to Claude. We ran it in ChatGPT, with a ticket good for 60 seconds.

#What happensWhat we saw
1An app-only tool returns a single-use ticketClaude lists it apart, as an app-only tool
2The view calls that toolno approval prompt in either host
3The view posts it to the frame, at the app's exact originClaude had no frame to post to
4The page exchanges the ticket for its own sessiona second exchange was refused
5The cookie is SameSite=None; Secure; Partitionedit came back on requests and on a page change

Step 1 rests on an assumption worth checking: that the ticket is minted for the person who connected. So we put the test server behind a sign-in of its own, connected it to ChatGPT and to Claude, and logged which sign-in every call carried. Both hosts found the sign-in by themselves and registered as clients. In both, the view's calls to the app-only tools arrived with the same token as the model's call that opened the view, sent from the host's own servers with the same user agent. Your server can't tell a call from the view and a call from the model apart. Keeping an app-only tool away from the model is the host's promise, not something the server can check, so the ticket has to be harmless if the model ever sees one: single use, gone in a minute, tied to one person and one app, and accepted only by that app's own page.

Two smaller things showed up in the same run. In Claude the view asked for its ticket before the model's call that opened it had been answered, so a view starts while that call is still in flight and can't count on its result arriving first. And Claude files any tool that has a view under a heading of its own, interactive tools, which on our account were set to ask before each run. Our test tool was marked read-only, and Claude still asked.

We set three cookies to see which would survive. The partitioned one came back, and so did a plain SameSite=None cookie. A SameSite=Lax cookie didn't, and Lax is what Chrome assumes when an app doesn't say. An app that keeps its session that way works in its own tab and arrives in the frame signed out.

Our Chrome profile allows third-party cookies, so this was the easy case. The ChatGPT iPhone app was the hard one. The page loaded, the form submitted and the ticket exchange worked, and then no cookie came back at all, partitioned or not, on a request or on a page change. Inside the frame the browser reported cookies as switched off, while local storage still worked. So a cookie session can't hold in that frame.

That makes a check part of the design. The page has to look for its own cookie after the exchange and, when it isn't there, tell the view, which then offers a link out instead. On a phone that's the normal path, and the link isn't the same in both apps. ChatGPT asks first and opens its own in-app browser, which keeps cookies apart from Safari, so the person signs in there once. Claude asks first and hands the link to Safari.

One result surprised us. We opened the test a second time, in a new conversation and under a different view origin, and the page arrived already carrying the first run's cookies. A partitioned cookie is keyed to the site in the address bar, which is chatgpt.com every time, and the conversation isn't part of the key. If you build this, exchange a fresh ticket every time the app opens and replace whatever session is there. The cookie you find may belong to the last person who used ChatGPT in that browser.

Last, your app has to agree to be framed. If it sends a frame-ancestors policy, and an app with signed-in pages should, the browser checks that policy against every frame above the page. In ChatGPT ours saw the view's origin twice and then chatgpt.com, or skybridge.oaistatic.com in the iPhone app, so a policy for ChatGPT has to allow both. That origin was a host under web-sandbox.oaiusercontent.com, and when we asked for a domain it became our own host name with dashes in place of dots. The standard field, _meta.ui.domain, is enough for that. A later run set only that field, without ChatGPT's own openai/widgetDomain key, and got the same host. Claude runs views on a host under claudemcpcontent.com, and its getting-started page gives the formula: the first 32 hex characters of the SHA-256 of your server URL. Claude used that exact host when we set it and a different one when we didn't.

So set the view's domain on both hosts and the list your app has to allow stays fixed. OpenAI requires one anyway when you submit a plugin with UI. And name the exact host in your policy. Anthropic warns that with a wildcard over claudemcpcontent.com, "the MCP Apps of other connectors can frame your site".

We shipped the button first, then gave the framed app its dialogs back

We built it the same day, in the order the test pointed to. One tool opens any app in a workspace, and one view serves every host. The view reads the frame domains the host granted, matches them against the wildcard it declared, and frames the app only when the pattern is on the list. Otherwise it shows a card with the app's name and a button that opens it in Clawnify.

Claude showed the card, in Chrome and on the iPhone. So did the ChatGPT iPhone app, where the button asks first and then opens ChatGPT's in-app browser. ChatGPT in Chrome showed the app itself: our content manager, signed in through the ticket handoff above, reading its own data inside the frame. Its expand control moved the view to a full-height panel beside the conversation.

That left the sandbox. Adapting each app to one host's frame would have meant changing the 55 templates and every app built from them. So the edge in front of our apps adds one small script instead, and only to pages opened through the frame's entry. In their own tab the apps never load it.

Your app doesThe script, in the frameWhat we saw in ChatGPT
confirm()draws a dialog inside the page, replays the click on OKthe dialog appeared, Cancel kept the post
window.open, a new-tab linkasks the view, which sends the host's open-link requesta browser tab opened at once
A download linkfetches the file, hands it to the host's download requestnot run yet
Copy to clipboardfalls back to the older copy commandnot run yet

The first version of that dialog had two flaws worth knowing if you draw your own. The click on Cancel went on to the app underneath, which read it as a click outside its editor and closed the editor. And a second confirm() stacked a second dialog on the first. A dialog drawn over someone else's page has to keep its own clicks to itself, and show one at a time.

Two things cost us time that we didn't find in the documentation we read. ChatGPT kept a connector's tool definitions until we pressed Refresh tools in its settings, so a new view address went unnoticed until then. And after the refresh it kept serving its stored copy of the view's HTML under the same ui:// address, so a fix to the view did nothing until the address changed. Put a version in the view's address, and change it with every change to the view.

Where that leaves it, on 20 November 2026: people using our connector in Claude get the card now. For ChatGPT, new tools reach the people using our published plugin only once OpenAI has checked them, and we sent the version that describes them for review the same day.