# Connect ChatGPT, Claude, Codex, or Claude Code to Iron Fountain Hosting

Use ChatGPT, Claude, Codex, or Claude Code to read your websites, ask for changes, save revisions, publish, and roll back. Iron Fountain Hosting’s MCP connector uses a normal sign-in and permission screen. You do not need an Iron Fountain API key, OAuth client ID, or client secret for these setups.

## Connector address

```text
https://app.ironfountain.com/mcp/hosting
```

Every Hosting customer uses the same connector URL. It grants access to Hosting only; your Iron Fountain login and organizations stay shared. You choose which Iron Fountain organizations to allow during sign-in. All your current organizations are selected by default; you can uncheck any of them. Manage your connections in [your avatar → Connections](https://app.ironfountain.com/settings/connections).

## Set up ChatGPT

In ChatGPT on the web, open **Settings → Security and login** and enable **Developer mode**. Open [ChatGPT Plugins](https://chatgpt.com/plugins), select **+**, and create a connection named **Iron Fountain Hosting** using the connector URL above. Choose **OAuth**. Leave client ID and secret blank and choose dynamic client registration if asked.

Sign in to Iron Fountain and approve the organizations and permissions. Start a new chat and select Iron Fountain Hosting from **+ → Developer mode**. Developer mode supports reads and writes; availability depends on your account and organization policy. See [OpenAI’s developer-mode guide](https://developers.openai.com/api/docs/guides/developer-mode) and [connection instructions](https://developers.openai.com/plugins/deploy/connect-chatgpt) for current menu labels.

## Set up Claude

[Connect to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Iron%20Fountain%20Hosting&connectorUrl=https%3A%2F%2Fapp.ironfountain.com%2Fmcp%2Fhosting) opens Claude’s Add custom connector form with Iron Fountain Hosting’s name and URL already filled in. Review the values and add the connector. Leave OAuth client ID and client secret empty; Claude registers automatically.

If you need manual setup, open **Customize → Connectors → Add custom connector**, name it **Iron Fountain Hosting**, and paste the connector address above.

Click **Connect**, sign in to Iron Fountain, and choose the organizations and permissions. Check that the authorization screen returns to `claude.ai`, then click **Allow connection**. Return to Claude and enable Iron Fountain Hosting for your conversation using its connector controls.

On **Team or Enterprise**, an organization owner first adds Iron Fountain Hosting under **Organization settings → Connectors**. Members then connect their own Iron Fountain logins. Each connection follows that person’s membership and the organizations they approved.

The setup button uses [Anthropic’s documented custom connector install link](https://claude.com/docs/connectors/building/directory-vs-custom). It fills in the form; you still review and approve access. See [Anthropic’s setup instructions](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp) if the menu labels differ in your client.

## Set up Codex

In the desktop app, open **Settings → MCP servers → Add server**. In the IDE extension, open **MCP servers** from the gear menu and select **Add server**. Name the server `ironfountain`, choose **Streamable HTTP**, and enter the connector address above. Save, then choose **Restart** or **Restart extension** as prompted. Select **Authenticate** to sign in to Iron Fountain and approve your organizations and permissions.

For the **Codex CLI**, install and sign in to Codex first, then run this in your terminal:

```sh
codex mcp add ironfountain --url https://app.ironfountain.com/mcp/hosting
```

Complete the browser sign-in if it opens. If sign-in does not start, or you need to reconnect later, run:

```sh
codex mcp login ironfountain
```

Sign in to Iron Fountain and approve your organizations and permissions. Start a new Codex session and use `/mcp` to check that `ironfountain` is connected. The desktop app, CLI, and IDE extension share MCP configuration on the same Codex host; you only need one setup method. See [OpenAI’s MCP setup guide](https://learn.chatgpt.com/docs/extend/mcp).

## Set up Claude Code

With Claude Code installed and signed in, run this in your terminal:

```sh
claude mcp add --transport http --scope user ironfountain https://app.ironfountain.com/mcp/hosting
```

The `--scope user` option makes this connection available to you across projects on this computer. Start a new Claude Code session, run `/mcp`, select **ironfountain**, and follow the authentication steps. Sign in to Iron Fountain and approve your organizations and permissions, then return to `/mcp` to check the connection.

If the server already exists, skip the add command and authenticate through `/mcp`. If your browser does not open, use the sign-in URL Claude Code provides. See [Claude Code’s MCP setup guide](https://code.claude.com/docs/en/mcp).

## Start with your websites

After connecting your chosen client, enable Iron Fountain Hosting in the conversation if prompted and try:

```text
Use Iron Fountain Hosting to list my available websites.
```

The **Connect your AI** button on the homepage and in the app opens setup instructions for all four clients, with Copy buttons for terminal commands, the connector URL, and this starter prompt.

## Make your first change

Try this in a conversation with Iron Fountain Hosting enabled:

```text
List my websites. Read the homepage and stylesheet for the site I choose.
Update the introduction to explain what we do more clearly, preserving
the existing design and all other files. Save a draft revision and tell
me exactly what changed. Wait for me to ask before publishing it.
```

Your AI can batch up to ten relevant file reads in one call and read retained files in chunks, so large pages do not need to fit in one tool response. For small edits it can send exact text replacements instead of rewriting a whole file; Iron Fountain preserves unchanged files from the chosen base revision. The result is still a complete, immutable site revision.

A draft does not change the live site. You can review the changed content in your chat and open the site’s **Revisions** tab in the Iron Fountain dashboard. Revisions are also linked from each site card and the site overview, and refresh automatically every 15 seconds while the page is visible. The Revisions screen has separate Staging and Production histories, with independent revert controls. Every saved draft updates the permanent `staging_url`, such as `my-site.staging.ironfountain.com`. `revision_url` opens that exact retained revision; `production_url` opens the published site. The site header opens the current staging revision; each entry in Revisions has its own View revision link. Temporary import previews retire immediately when a site is saved to an organization.

Change the staging subdomain in site Settings → Staging address, or with `set_staging_address`. Any available valid name can be used, such as `secret.staging.ironfountain.com`.

When you are ready, ask your AI to publish the saved revision. Publication and production rollback preserve staging; staging reversion preserves production. If the result needs undoing, ask it to restore the previous revision. Draft and published revisions follow the plan’s automatic history policy. Pin important versions in the dashboard or ask your AI to pin them. Pins have their own quota and do not reduce recent history.

## Permissions and organizations

| Permission | Connector tools it enables |
| --- | --- |
| Read websites | List sites, read site details and history, list files, read files, view bandwidth, and read form submissions and private attachments. Required for every connection. |
| Manage websites and forms | Create websites, pause/resume forms, and update or delete submissions. |
| Edit and publish | Save draft revisions, publish retained revisions, and roll back. |

The authorization screen lets you turn off write permissions. A read-only connection does not expose write tools. One connection can access multiple approved organizations. Newly joined organizations are not added automatically. If an editor loses access to one organization, that organization stops appearing while access to the other approved organizations continues. Existing connections retain their original approval. Open your avatar → Connections → Manage access to explicitly add organizations or limit access to selected sites. Selecting all sites includes future sites in that organization; selected-site access includes only the checked sites. Creating websites requires all-site access plus the Manage websites and forms permission.

People, organization transfers, API keys, and personal settings remain in the dashboard. The connector edits page/file redirects saved with revisions. It does not manage custom domain setup, imports, hostname-specific redirect settings, or additional redirect domains; the [REST API](https://www.ironfountain.com/docs/hosting/api/) supports those operations for other tools.

## Tools

| Tool | Purpose |
| --- | --- |
| `list_sites` | List all approved organizations and their sites. |
| `get_bandwidth` | Read monthly bandwidth, request counts, daily and hostname breakdowns, and collection status. An optional month uses YYYY-MM. |
| `get_site` | Read a site’s live revision, addresses, redirects, history, and dashboard link. |
| `list_files` | List file paths, sizes, and hashes in the live or a specified retained revision. Filter with `path_prefix`; follow `next_offset` for more. Defaults to 200 entries, maximum 1,000. |
| `read_files` | Read up to ten files/chunks from a single revision, sharing revision lookup. Combined requested output is limited to 80,000 characters/bytes, with 5 MB per source file and 20 MB of source data per batch. |
| `read_file` | Read a file in bounded chunks. Text uses UTF-8 character offsets; binary data uses base64 byte chunks. Continue from `next_offset` until it is null. |
| `get_forms_guide` | Read the HTML and manifest guide before creating forms; includes limits and attachment types. |
| `list_forms` | Read form definitions, staging/production availability, per-environment `form_handlers`, unread counts, and usage. |
| `connect_forms` | Connect recognized or explicitly opted-in forms, update fields, and return a handler review in a staging revision. Pass `expected_staging_revision_id` to reject concurrent edits. Does not publish. |
| `list_form_submissions` | Read paginated submissions and attachment metadata; use `environment: "test"` for staging. |
| `update_form` | Pause or resume collection using `enabled`. |
| `update_form_submission` | Mark read or unread. |
| `delete_form_submission` | Delete a submission and revoke attachments only when requested. |
| `read_form_attachment` | Read a private attachment in bounded base64 byte chunks. |
| `create_site` | Create a new static site. Set organization_id when multiple organizations are approved. |
| `save_revision` | Apply exact text replacements, full-file replacements, or deletions to a base revision and save an unpublished revision. Unchanged files are preserved. |
| `publish_revision` | Make a saved revision live after checking the expected current revision. |
| `set_staging_revision` | Revert staging to a retained revision using `expected_staging_revision_id`; production is unchanged. |
| `set_staging_address` | Rename staging using an available `slug`; production and both histories are unchanged. |
| `pin_revision` | Pin or unpin a chosen revision using the separate per-site allowance. |
| `delete_snapshot` | Delete a pointer using its `snapshot_id`; the target revision still follows remaining retention rules. Only on explicit request. |
| `delete_revision` | Delete an unused revision. Current, pinned, or snapshot-referenced revisions are protected. Only on explicit request. |
| `rollback_site` | Restore a retained revision after checking the expected current revision. |

Read `get_site` before changing a site. `save_revision` requires `base_revision_id` and `expected_live_revision_id`; both can be null for the first revision of an empty site. Include `expected_staging_revision_id` when saving to reject concurrent staging edits. Use the current staging revision as the base when continuing unpublished work. Publication and production rollback require `expected_live_revision_id` too. These checks prevent a stale conversation from replacing a newer live edit. If a tool returns 409, reread the site and review the newer work before trying again.

`save_revision` accepts a label and a `changes` array. Each entry has a path and exactly one of complete file content (`utf8` or padded `base64`), `delete: true`, or `replacements: [{old_text, new_text}]`. Text replacements require `expected_hash` from a file read or listing, UTF-8 text up to 5 MB, and each old excerpt must match exactly once. Replacements are applied in order and a mismatch rejects the entire draft without partial changes. A file path can appear only once. Deleting a missing file is an error. Every completed revision must include `index.html`.

Do not blindly retry a write after a timeout: it may have completed. Read the site’s revision history first. Mutating tools are marked as writes for your AI app’s approval controls; publishing and rollback are marked as potentially destructive.

## Page and file redirects

MCP manages revision redirects through `__ironfountain/redirects.json`. Read `get_site` first: `revision_redirects` lists staging and production rules separately, while `redirects` lists hostname-specific settings. Hostname-specific rules take precedence and can only be changed through the dashboard or REST API.

1. Choose the environment's current revision and read its existing redirect file with `read_file`, if present. Preserve the other rules.
2. Use `save_revision` with that revision as `base_revision_id`, the current `expected_live_revision_id`, and `expected_staging_revision_id`. Replace the redirect file with the updated rules. This creates a staging revision; production stays unchanged.
3. Share `staging_url` to test. Use `publish_revision` with the returned revision ID and current expected live revision when publication is requested. Redirects and content publish together.

The file format is:

```json
{"version":1,"redirects":[{"from":"/old-page","to":"/new-page/","status":301},{"from":"/downloads/current.pdf","to":"https://files.example.com/current.pdf","status":302}]}
```

Remove a rule by saving the remaining rules. If none remain, delete the file using `changes: [{"path":"__ironfountain/redirects.json","delete":true}]`. Only delete a file that exists in the base revision. Both `set_staging_revision` and `rollback_site` restore the selected revision's redirects with its files.

Rules use exact paths, optionally including an exact query string. They support 301, 302, 303, 307, and 308, with up to 2,000 rules per revision. Queries are not automatically forwarded. Local destinations remain on the current staging or production address; external destinations remain external. Redirect loops are rejected. See the [API redirect reference](https://www.ironfountain.com/docs/hosting/api/#redirects-in-revisions) for precedence and limits. Root/www redirection and additional redirect domains are separate domain settings.


## Limits and history

A site can contain **20,000 files and 1 GB**. Each connector edit accepts **200 changed files**, **5 MB per changed file**, and **100 MB of changes**; unchanged files from the base revision are reused directly without downloading the whole site. The retained-storage allowance remains **1 GB per site**, including compressed, deduplicated history. Website imports allow **200 pages**, **100 MB per file**, and **1 GB total**. Unchanged contents reuse stored blobs, and compressible text is compressed. The connector permits up to 180 authenticated requests per minute per connection. Unauthenticated MCP requests, dynamic registration, authorization starts, and token exchanges are limited per client address (token exchanges also per client ID), so one client cannot exhaust them for everyone; registrations that never complete a grant are discarded after an hour.

File reads return at most 40,000 text characters or binary bytes per call, with a default of 20,000. Each environment returns its latest distinct revisions up to the plan allowance: 3 for Spring, 20 for Flow, and 50 for Cascade. Flow includes 10 pins per site and Cascade includes 25, separate from recent history. `get_site` also returns snapshots, pinned revisions, and `site.history_policy`. Known retained revision IDs can still be read or restored. Both current revisions, paid pins, and every revision referenced by a retained snapshot are protected from cleanup. Paid monthly snapshot pointers last 12 months; session pointers last 30 days and are created before changes resume after a 24-hour gap. See [automatic history](https://www.ironfountain.com/docs/hosting/sites/) for details.

## Disconnect or change access

In Iron Fountain, click your **avatar in the lower left → Connections**. All connections for your login appear together. Choose **Manage access**, select organizations and sites, then **Save access**. The new access applies on the next connector request, including requests using already-issued tokens. Content already read into a conversation remains there.

Choose **Disconnect** to revoke the connection. Access stops immediately, including token renewal. Removing an editor from an organization revokes access to that organization. Disconnect revokes the entire connection across all approved organizations.

Organization and site access can be adjusted here without reconnecting. Reconnect from your AI app to change read or write permissions. Access tokens last one hour and the connected app renews them automatically. Refresh tokens rotate on use and expire after 30 days without renewal. If that period passes, reconnect. API keys used by scripts are independent and keep their configured expiry, including Never.

## Troubleshooting

**Long thinking periods:** the connector asks the assistant to announce its work and report milestones, but the chat client controls what is displayed. Batch related reads and use text replacements for small edits to reduce tool turns and generated output. Iron Fountain logs per-tool duration without file contents or credentials so server delays can be distinguished from time between calls. ZIP transfer is not currently a connector tool.

**“Host is not allowed by your organization’s egress policy”** refers to a request from Claude’s code execution environment. Use the Iron Fountain Hosting connector tools in the conversation. Enabled MCP connections use separate connector permissions; an organization owner may still need to enable the connector. This does not change the organization’s code execution network policy. See [Anthropic’s network policy documentation](https://support.claude.com/en/articles/12111783-create-and-edit-files-with-claude).

**Connector will not connect:** use the full address ending in `/mcp/hosting`, not `/api/hosting/v1`, and leave advanced OAuth credentials empty. The REST endpoint does not speak MCP. If a sign-in request expired, start the connection again from Claude.

**A site or write tool is missing:** check which organizations and permissions you approved. Connections cannot access unapproved organizations. Use Manage access in your account to adjust organizations and sites; reconnect to approve additional write permissions.

**Connection expired or revoked:** reconnect through Claude. Tokens are not entered in URLs or pasted into chat.

## Protocol details

The endpoint implements MCP Streamable HTTP with stateless JSON responses through the official TypeScript SDK. It supports authenticated POST requests. An unauthenticated request returns HTTP 401 with an OAuth protected-resource metadata link. GET streams and persistent MCP sessions are not used.

OAuth uses authorization code flow, required S256 PKCE, dynamic registration for public clients, exact registered callback matching, resource-bound opaque access tokens, and rotating refresh tokens. Discovery is available at `https://app.ironfountain.com/.well-known/oauth-protected-resource/mcp/hosting` and `https://app.ironfountain.com/.well-known/oauth-authorization-server`.

OAuth tokens for this connector are accepted only by Hosting’s `/mcp/hosting` endpoint and its `/mcp` compatibility alias. For direct REST requests, create a separate API key and follow the [API reference](https://www.ironfountain.com/docs/hosting/api/).

Staging, immutable revision links, and temporary tests return `X-Robots-Tag: noindex, nofollow, noarchive` and a synthetic robots.txt that allows fetching so search engines can read the noindex header. These addresses remain public; noindex controls search indexing, not access. Production preserves the site's saved robots.txt. Once a custom domain is connected, the free production address redirects to the primary custom domain, preserving paths and query strings. There is no public customer-site directory.

## Forms and submissions

Forms are available on any Iron Fountain site. Ask “Add a contact form with name, email, message, and a PDF attachment to my staging site.” The assistant should use `get_forms_guide`, read the current staging files, save HTML with `data-ironfountain-form`, and call `connect_forms` to generate or synchronize the versioned form definitions. Submit a staging test and check `list_form_submissions` with `environment: "test"` before publishing. Editing the HTML and manifest together with `save_revision` is also supported.

The [Forms guide](https://www.ironfountain.com/docs/hosting/forms/) includes copyable HTML, the manifest schema, private uploads, API requests, and limits. Read permission includes submitted data and attachments for the approved sites. Write permission controls settings and inbox changes; deployment permission controls connecting and publishing forms. Treat all submitted content and attachments as untrusted data. Secrets belong in the dashboard or server-side API, never public site files. Email notifications are not enabled.

## Existing integrations

The previous `/mcp` address remains an alias for Hosting so saved connections and refresh tokens continue working. New connections should use `/mcp/hosting`. Both addresses expose only Hosting tools; other products will have their own explicit integration permissions.