MCP App Store
by KeenEthics
Stacktree icon

Stacktree MCP Server for ChatGPT

By Yume Studios

Overview

Stacktree turns the pages ChatGPT and Codex build for you into a private link anyone can open in a browser. Ask for a report, a proposal, a dashboard or a one-page site, then publish it in the same conversation. The page opens with no account and no sign-in, on a link that is private and unguessable by default. Revising the page replaces it in place, so a link you have already sent shows the latest version. Stacktree is built for work that leaves the conversation: client deliverables, stakeholder updates, and anything someone outside your chat needs to see. - Add a passcode, or limit a page to people with an email address at one company. - Mint a named link for each recipient and see who opened it. - File pages under a client space, so everything for one customer lives at one address. - Let clients comment on the page itself, with no account. ChatGPT can read their comments, fix the page and mark each one resolved. - Set a page to expire, take it down, or put an earlier version back. Pages are private by default. Links are unguessable, pages ask search engines not to index them, and a check before publishing looks for personal data and secrets in the page. Stacktree needs a Stacktree account. You connect it the first time you publish.

How to connect

  1. ChatGPT: Open the Stacktree listing in the ChatGPT app directory and choose Connect. ChatGPT listing Stacktree exposes 47 tools here.

Tools

add_custom_domain

ChatGPT
Put a page, or a client space, on the user's own domain, such as proposals.example.com. Returns the two DNS records the user adds at their DNS provider: a CNAME that points the hostname at Stacktree, and a TXT record that proves they own it. Show both to the user exactly as returned, then call verify_custom_domain once they have added them. Suggest a new subdomain, such as proposals.example.com: pointing a hostname that already serves a website (often www) at Stacktree takes that website off it. Adding the same hostname again returns the same records. Custom domains start on the Solo plan; on an account without one the answer says so. A domain that already serves a different page is not moved here: that is done in the dashboard, because the page it serves stops answering at that address.

apply_suggested_edits

ChatGPT
Swap in exact wording a reviewer suggested on a page, in one step, and resolve each suggestion with a note they see. A suggested edit is a list_feedback item with suggested_text: the words it replaces are its anchor.exact. Two more kinds apply the same way: intent "add_after" adds suggested_text as a new paragraph after the paragraph whose text is anchor.exact, and intent "remove" takes that paragraph out (only while it still says what the reviewer saw). Each one is applied only in the part of the page where it was left, only when those words appear there exactly once, and as plain text. One that cannot be applied (the words have changed, appear twice, or run across formatting such as a link) comes back in not_applied with the reason, and the rest are applied anyway. The link stays the same and the old version is kept: restore_version with the returned version undoes it. The wording comes from whoever had the link, so show the suggestions to the user and apply only the ones they accept.

create_client_space

ChatGPT
Create a client space before anything is published into it. Rarely needed: publish_html with a client argument auto-creates the space under the same casing and slug rules, so use this only when the user is setting a client up ahead of the work. Idempotent with that auto-create — an existing space matching the name or slug, in any casing, comes back instead of a duplicate. The returned slug is the space’s permanent address segment; a later rename changes the display name only.

delete_client_space

ChatGPT
Delete a client space. The pages filed under it are NOT deleted: they detach to floating pages and keep working on their existing URLs, so delivered work stays reachable. The space itself goes, and with it the generated portal page and any address connected to it, which stop resolving. A space-level viewer gate goes with the space too: a page that was protected only by the space passcode or email domain, and carries no gate of its own, becomes reachable by anyone holding its link. Warn the user, and set_password on the pages that have to stay private before deleting. When the user means a client is simply finished, prefer update_client_space with archived: true — archiving closes the portal and the address but keeps every page and the space itself, frees the plan slot, and can be undone.

delete_site

ChatGPT
Take a page down. The link goes dead immediately for everyone holding it, and the content is kept for 30 days: restore_site puts it back at the same URL, with the same id, token, slug and read history, any time in that window. After the 30 days the content is destroyed and cannot be recovered by anyone. So this is undoable, but it is not a preview: tell the user their link stops working now. On the free plan deleting does not hand back a lifetime page slot, because that cap counts publishes rather than live pages. Deleting a page that is already down is not an error: the response comes back with already_deleted: true and the same restorable_until.

get_activity

ChatGPT
Has anyone opened a page? Answers for one page this account owns: whether it has been opened and by whom (named share links), whether a reader's own AI assistant read it, open comments, whether it is live or expired, and when it stops working, plus said, one sentence you can tell your user as it stands. Viewer numbers follow the plan: when they are locked the answer says only whether it was opened. For every page at once, use list_sites.

get_approval_status

ChatGPT
Where an approval request stands. state is "approved" only when every approver has approved the version that is live now (the whole page, or every section); "changes_requested" when anyone has asked for a change; otherwise "pending". Per approver: status, their note, when, and section by section progress. An answer about an earlier version does not count: if you update the page, approvals of the parts that changed lapse.

get_content

ChatGPT
Read a page’s content back. format "html" (the default) returns the exact stored index.html, byte for byte, which is the only form you can edit and hand to update_site; format "text" returns the same page stripped to plain text — no markup, CSS, scripts or SVG — which is what you want when you only need to read, summarise or quote a page and the markup would be most of the tokens. Only pages this account owns, gated ones included. A page that expired or was deleted still reads back until its restore window closes, so this doubles as "get me a copy before it is purged"; a page taken down for abuse does not. Never edit the text form and publish it: that would throw the page’s design away.

get_design_guide

ChatGPT
Fetch the Stacktree house design guide for improving a published page. Call this BEFORE any request to make a page look better, more polished, more professional, or "beautiful" — it contains the assess-first workflow (including when NOT to restyle a page that already has a deliberate design), the quality floor, and the CSP constraints published pages run under. Then follow it: get_site → assess → rebuild or elevate → update_site.

get_me

ChatGPT
Who this connection is publishing as, and what its plan actually allows. Returns the account’s plan, the signed-in email, how many pages it holds and how many lifetime publishes it has spent, and a limits object. READ limits RATHER THAN QUOTING NUMBERS FROM ANY OTHER TOOL DESCRIPTION: those describe the free plan, the account you are connected to may be on any plan, and limits is what the server will actually enforce. Worth calling before promising a permanent link (max_expiry_hours), before promising a passcode or an email gate (passwords, email_gates), and when a publish comes back 402 or 429, so you can tell the user which wall they hit and how much of it they have used. The email is also the answer to "where did my page go": pages live in one account, and the commonest cause of a missing page is a second one, so say WHICH account is connected rather than that the page does not exist. auth_method reports how this connection authenticated ("apiKey" or "oauth"). It reads nothing about anyone else and touches no page.

get_passcode

ChatGPT
Show the passcode set on a page this account owns, so it can be sent to the client again. Works for passcodes set since 13 September 2026 (kept as an encrypted copy beside the hash the gate checks). An older one answers not_retrievable: the page still asks for it, and the fix is set_password with a new one, then send that.

get_revision_brief

ChatGPT
Everything that came back on one page, as the brief for its next version: the reviewer's change requests, their questions grouped by theme, their approvals, the notes the owner left on their own page as a fix list, each with the exact passage or image it is pinned to and whether it still matches the page; then reactions, questions readers asked the page, what is already resolved, and suggested edits. Call it when the user asks what the client thought or wants to revise a page with feedback. Then get_site, edit, and publish_revision to publish the new version and resolve what it answers in one step.

get_site

ChatGPT
Read the current HTML source of a site you own, so you can edit it and call update_site to change it in place. Returns the exact stored index.html (not a rendered or text-stripped version), preserving CSS and inline charts. Use this to personalize a template or iterate on a published page without re-fetching the live URL. To READ a page rather than edit it, get_content with format: "text" returns the same page stripped of markup, which is a fraction of the tokens.

list_client_spaces

ChatGPT
List the client spaces on this account: slug, name, page_count, last activity, hostname (the space’s own address, e.g. acme.theiragency.com, when one is connected) and portal_enabled (whether the space serves a generated client portal at that address). Spaces group published pages per client ("file this under Acme"). publish_html auto-creates spaces, so an empty list just means nothing has been filed yet — publish with a client to start one. Connecting an address and enabling the portal are done in the dashboard (DNS is involved).

list_custom_domains

ChatGPT
Every custom domain on this account: the page or client space it opens, whether it is verified, its HTTPS certificate status, and for one not verified yet, the DNS records it still needs. Read-only.

list_feedback

ChatGPT
Read viewer comments left on a site, unresolved first. Each item from the page comment layer has target (one line saying what it is about, in the page source's own terms), target_kind (text | image | video | audio | embed | graphic | element | page) and anchor: for text the exact quoted words plus prefix/suffix; for images the src attribute as written in the HTML, alt text and the point clicked (0-1 across/down); for video/audio the src and the timestamp in seconds; anchor.selector is a CSS path to the element. Find the target in get_site's HTML by quote or src, not by selector alone. Older Agentation items carry element, selected_text, intent and severity instead. Open comments also carry on_page: true while their target is still in the page, false once an edit has removed or reworded it (usually answered, so resolve it), null when that cannot be told from the source. The loop: list_feedback → edit with get_site/update_site → resolve_feedback with a note saying what changed (the reviewer sees that note).

list_responses

ChatGPT
What readers sent through the forms on a page. A form in published HTML marked <form data-stacktree-form="name"> posts to the page itself; only the fields the form declares are kept. Newest first.

list_sites

ChatGPT
List sites owned by the authenticated user, newest-updated first. On plans without viewer numbers each site carries metrics_locked: true, view_count/unique_viewers/last_viewed_at are null, and opened still reports whether anyone has opened it. Each site carries its client space (or null); filter with the client argument. Pages that expired or were deleted stay in this list rather than disappearing: check deleted_at before handing anyone a url, because a row with deleted_at set is a dead link, and restore_site puts it back until restorable_until passes. Paged: the response carries has_more, and when it is true, next_before and next_before_id. To read the rest, call again passing those two values as before and before_id, and repeat until has_more is false.

list_versions

ChatGPT
List earlier versions of a page this account owns, newest first. Every update replaces a page in place, and the content it replaced is kept here: one snapshot per update, taken the moment before the new content landed. Call this whenever an update turned out wrong, or the user asks what a page said before, or asks for last month’s copy back, then restore_version with the id. Do NOT publish_html to recover an earlier version: that mints a second page at a different URL. Each version carries source (how the update that produced it arrived) and partial. SINGLE FILE ONLY: on a page with other files only index.html is kept, and partial is 1 to say so; an end-to-end encrypted page is not snapshotted at all. Retention is per plan, the last 5 versions on free and 50 on paid, so an old version can age out. An empty list is not an error and does not mean the page is broken: it means the page has not been updated yet, or its versions have aged past the cap.

open_html_file

ChatGPT
The Stacktree viewer for an .html file the user opens in ChatGPT desktop: preview it, publish it to a private link, add a passcode, send it to a named client, and keep the page in sync as the file changes. ChatGPT calls this itself when the user opens the file. A file path does not work here: to publish a file you can read, call publish_html with its contents.

publish_card_open

ChatGPT
Used by the Stacktree publish card in the chat: a short-lived owner preview link for one page, which opens it without counting as a visit and without asking for its passcode. Read-only. Not a link to send anyone: it stops working after 15 minutes.

publish_card_send

ChatGPT
Used by the Stacktree publish card in the chat when the user types who a page is for: records that person for the page and returns their own link. It sends nothing. An agent answering the user should use whos_it_for instead.

publish_card_status

ChatGPT
Used by the Stacktree publish card in the chat to refresh itself: the page’s link, whether and by whom it has been opened, its passcode, expiry and client. Read-only. An agent answering the user should use list_sites or list_share_links instead.

publish_html

ChatGPT
Turn HTML into a link a person can open in a browser. It only ever creates a new page: it never changes or deletes one that already exists (update_site replaces a page in place). Reach for this whenever a page you produced has to be seen by someone who is not in this conversation — a client, a teammate, a reviewer, a channel — or when the user says "publish this", "share this", "send it to X", or asks for a preview link to something you built. A rendered preview inside a tool is not a link: if it has to travel, publish it. Returns { url, id, expires_at, ... }; hand the url back. Privacy-first defaults: unguessable token URL, plan-aware expiry (permanent on paid plans, 7 days on free — its ceiling), a safety scan that blocks accidental publication of personal data or secrets (nothing is collected or stored by the scan), strict CSP, X-Robots-Tag: noai. Pass expires_in_hours: "never" for permanent links — on the free plan a permanent page is REFUSED, not silently shortened: you get 409 expiry_clamped naming the date it would have got, and either you pass accept_clamp: true to take the 7 days or you tell the user the plan cannot make a link permanent. Never report a page as permanent without expires_at being null. Read expires_at_iso and ttl_seconds off the response and tell the user when the link dies. The free plan allows 3 pages in total; the count is lifetime, so deleting a page does not free the slot. RETRYING: pass idempotency_key (any unique string, a UUID is ideal) and a retry of the same call returns the SAME page instead of publishing a second one. Reuse the key when you retry after a timeout or an unclear failure; use a new key for new content.

publish_revision

ChatGPT
Publishes the new version of a page that has feedback and resolves the comments it answers, in one step. The HTML is replaced in place, exactly as update_site does (same link, so everyone holding it sees the new version; the old one is kept in list_versions). Then each listed comment is resolved with its note, and one message back to the reviewer is left with them. The reviewer sees the notes and the message next to their comments the next time they open the page. Use it instead of update_site when the new version answers feedback from get_revision_brief. If the update is refused, nothing is resolved.

report_missing_feature

ChatGPT
Tell the people who build Stacktree about something the user wanted that Stacktree cannot do with these tools, such as scheduling a page to go live later. Use it once per task, after checking the tools and the docs, and say to the user that you passed it on. Not for errors: those reach us already. Describe the task, not the user: no names, email addresses or page content. Nothing on any page changes, and nobody replies to the report itself.

request_approval

ChatGPT
Get a named person's yes on a page. Publishes the HTML (or uses a page already published) with a sign-off panel, and makes one private link per approver that carries their name. Each approver opens their link, reads the page and chooses Approve or Request changes, for the whole page or section by section, with an optional note. Returns the links to send and an approval_id for get_approval_status. The result is a timestamped record of who approved which version, not a legal e-signature.

resolve_addressed_notes

ChatGPT
After update_site: resolve the open notes the new version appears to answer (comments whose words are gone, sections that were asked to change and have been edited), with one line each reviewer sees next to their own note. Only notes the update actually touched are resolved. Leave ids out to resolve all of them.

resolve_comments

ChatGPT
Resolves several comments on one page in one call, each with a short note, plus one optional message back to the reviewer. For when nothing needs publishing: approvals, or comments an earlier update already answered. The person who left each comment sees the note next to it on the page, so write it to them. Ids that are not open on this page are skipped and reported back.

resolve_feedback

ChatGPT
Mark a feedback item as addressed after fixing the page. Pass the feedback item id from list_feedback, and a short note describing what you changed: the reviewer who left the comment sees it on the page.

restore_site

ChatGPT
Restore a page that was deleted or expired in the last 30 days. It comes back at the same URL, with the same id, slug and history, so links already shared work again. Use it when update_site or a settings tool answers 409 site_deleted; publishing the page again would give it a new URL instead. A page past its 30 days, or one removed for breaking the terms of use, cannot be restored and answers 404. The response gives the new deadline in expires_at and expires_at_iso; tell the user that date. restored_for says which deadline it got: "grace" means the page had expired and is back for 48 hours, "kept" means it kept the deadline it had, and "plan" means it has the usual lifetime for the account. A 402 plan_site_limit_exceeded means the account has reached its number of live pages. If a retry answers 404, call get_site to check whether the first attempt already restored the page.

restore_version

ChatGPT
Put an earlier version of a page back at the same URL, after a bad update. Get the version id from list_versions first. Same link, same id, same read history, so nothing needs re-sending. This is NOT restore_site: restore_site brings back a page that was DELETED or expired, this rolls a live page’s content back to what it said before. The content that is live right now is snapshotted first, as a new version, so this is itself undoable and new_version in the response is the id that undoes it. Report that. SINGLE FILE ONLY: on a page with other files this puts index.html back and leaves the rest as they are, and the response carries partial: true saying so. A 404 version_not_found means that id is not a version of this page (it may have aged past the plan’s retention cap); a 409 site_deleted means the page itself has stopped serving, so call restore_site first and then this. Nothing is changed in either case.

set_client

ChatGPT
File an existing site under a client space (by name or slug, auto-created), or pass client: null to detach it to a floating page. Mirrors set_password: one site, one call.

set_client_feedback

ChatGPT
Switch how the people you send a page to can answer on it, with no account. comments: they select words, or click an image, video or section, and leave a comment only the owner sees (read them with list_feedback, fix the page with update_site, then resolve_feedback with a note the client sees). reactions: one-tap emoji. Pass either or both; omitted ones are left as they are. Not available on end-to-end encrypted pages.

set_email_gate

ChatGPT
Restrict viewer access to an email domain, to named people, or both. Paid plans only: on a free plan this returns HTTP 402 plan_viewer_gate_not_available. Anyone visiting the URL must verify, via a one-time magic link, that they own a listed address or one at a listed domain. Pass domain: null to clear. Mutually exclusive with set_password — clear one before setting the other.

set_expiry

ChatGPT
Set hours-from-now expiry, or null for never. A number longer than the plan allows is shortened to the ceiling and the response says so (expiry_clamped: true). Asking for NEVER on a plan that caps page lifetime is refused instead: 409 expiry_clamped, nothing changed, and the body carries the date it would have set. Pass accept_clamp: true to accept the ceiling, or tell the user the plan cannot make this page permanent. The response carries expires_at, expires_at_iso and ttl_seconds: quote that date rather than the one you asked for.

set_password

ChatGPT
Set or clear (null) the passcode viewers type to open a page. Works on every plan (free covers its 3 pages). The passcode belongs to the page: invent a new one, and never ask for or reuse anyone's real password or personal credentials.

stacktree_pages

ChatGPT
Lists the pages you have published on Stacktree, newest first, with their links, viewers and expiry.

unopened_pages

ChatGPT
The pages, and the named people, that have not opened what was sent to them an hour after it went up, newest first. Most pages are opened within the hour they are sent, so one that is still quiet has usually not gone out: hand the person their link again (each item carries it), or ask your user who an unnamed page is for and call whos_it_for. Read-only.

update_client_space

ChatGPT
Rename a client space, archive or unarchive it, or set the viewer gate that covers every page in the space. Omit a field to leave it untouched. A rename changes the display name only — the slug is a permanent addressing contract and never moves. Archiving frees the space’s plan slot and closes its portal and connected address to readers (they see a "no longer available" page); every page keeps working at its own link. Unarchiving reopens them, takes a slot back and returns HTTP 402 when the plan is full. password and allowed_email_domain gate the whole space and are inherited by pages already filed under it as well as ones published later; pass null to remove either. Passcodes work on every plan (free covers 3 across pages and spaces); email gates start on Solo, so setting allowed_email_domain on a free plan returns HTTP 402 plan_viewer_gate_not_available. Clearing a gate, or changing one the space already carries, always works. A 409 name_taken means another active space already answers to that name — report that rather than retrying with a variation, which would leave the user with two spaces for one client.

update_site

ChatGPT
Replace the HTML of an existing site in place. The URL stays the same, so everyone you already sent it to sees the new version without being sent anything. Use this — not another publish_html — every time you revise a page you have already published: iterating with publish_html strands the link people are holding on the old version and burns a page slot. The pre-publish safety scan runs on the new content too (MCP default: block), preventing accidental publication of personal data or secrets. A 409 managed_portal means this page is a generated client portal: it rebuilds itself from its space, so direct edits would be overwritten — the owner can "customize" it from the space settings in the dashboard, which stops regeneration for good. A 409 site_deleted means the page has stopped serving and is being kept for 30 days: call restore_site on the same id first, then update it. Do not publish it again: that mints a second page at a different URL. When the page has open client comments the response carries comments: how many are open, which ones no longer match the new version (ids_no_longer_on_page, most likely answered by this change) and what to do next: resolve those with resolve_feedback and a short note.

verify_custom_domain

ChatGPT
Check the DNS records add_custom_domain gave for a hostname and, once the TXT record is found, switch the domain on. Call it again afterwards to follow the HTTPS certificate: ssl_status "active" means the page opens at https://{hostname}. DNS changes can take from a few minutes to an hour to show. When the record is not found yet, the answer says what was expected and what was found: tell the user, and try again later rather than in a loop.

whats_new

ChatGPT
What happened on this account's pages since a time you give, newest first: who opened what (by name when the link was sent with whos_it_for), new comments and notes, approvals and change requests, form responses, a reader's own AI reading a page, and pages nobody has opened an hour after they went up. Each item has said, one sentence you can tell your user, and next, the tool that follows it up. Use it for a background check or a morning brief: pass the checked_at from your last call as since and nothing repeats. Covers the last seven days. Read-only: nothing is sent, and the owner's unread count in the dashboard is left as it is.

whos_it_for

ChatGPT
Record who a published page is for, by name, and get back that person’s own link to hand over. Ask your user who the page is for before you hand a link over, then call this once per person. Every open through the link comes back with their name, and if they have not opened it an hour after it went up, the owner’s dashboard says so. It records only: nothing is sent to anyone. Unlike create_share_link, the link keeps the page’s passcode or email gate in front of it. To file the page under the person’s company, use set_client.

Capabilities

WritesInteractive

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/stacktree"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/stacktree)