# Connect your AI agent to Pageree

> Install the Pageree MCP server in Claude, ChatGPT, Cursor, Codex, Claude Code, VS Code, Gemini CLI, Windsurf, Cline and OpenCode. Step-by-step setup, OAuth sign-in, and troubleshooting.

- Canonical: https://pageree.com/docs/
- MCP server URL: https://mcp.pageree.com/ (the origin root; do not append /mcp or /sse)
- Transport: Streamable HTTP. Authentication: OAuth with automatic client registration. No server to run, no API key.
- Setup instructions reviewed 2026-09-15 against the linked vendor documentation.
- Site index for agents: https://pageree.com/llms.txt

## Before you start

Model Context Protocol (MCP) lets your agent use tools from other services. Pageree runs the server; you connect your account from the agent you already use. You need a Pageree account (sign up at https://console.pageree.com/signup or sign in at https://console.pageree.com/login) and a current client with remote HTTP, OAuth, and permission to add custom tools. Your agent’s subscription is separate from Pageree; client plans and workspace policies can affect access.

## Connect Claude (chat app, Web & desktop)

**Before you connect.** Custom connectors require Claude Pro, Max, Team, or Enterprise. On Team and Enterprise, an organization owner adds the connector before members connect their own accounts.

1. **Open your connectors** In Claude, go to Customize → Connectors. On Pro or Max, choose + → Add custom connector. Organization owners use Organization settings → Connectors → Add → Custom → Web. Older versions may show Connectors in Settings.

2. **Add Pageree** Name the connector Pageree and paste this address. Leave the advanced OAuth client ID and secret empty, then select Add.

   MCP server URL:

   ```
   https://mcp.pageree.com/
   ```

3. **Sign in and enable it** Select Connect next to Pageree. Sign in to your Pageree account in the browser and approve access. In a new conversation, use + → Connectors to enable Pageree.

**What success looks like.** Pageree is connected and enabled for your conversation. Send the connection-check prompt below to confirm the agent can read your account.

Official Claude docs: https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp

## Connect ChatGPT (chat app, Custom MCP connection)

**Before you connect.** Use ChatGPT on the web with developer mode available. Access and allowed actions depend on your account and workspace policy; an admin may need to enable custom connections. Publishing needs permission to use write tools.

1. **Enable developer mode** Open Settings → Security and login → Developer mode. If your account still uses the Apps settings layout, look in Settings → Apps → Advanced settings.

2. **Create the connection** Open ChatGPT’s Plugins page (chatgpt.com/plugins) and select the plus button. In the older Apps layout, choose Create under Settings → Apps. Name it Pageree and enter the server URL under Connection. Use the exact address below, with no extra /mcp path.

   MCP server URL:

   ```
   https://mcp.pageree.com/
   ```

3. **Describe it and authorize** Use the description below. Choose OAuth when asked, sign in to Pageree, approve access, and review the discovered tools. Finish creating the connection.

   Connection description:

   ```
   Use Pageree to build, publish, and improve landing pages, collect leads, connect domains, and read page analytics. Start with get_skill_overview and follow the relevant Pageree skills. Confirm the intended changes before publishing.
   ```

4. **Add Pageree to a conversation** Start a new chat and select Pageree from the tools menu. If the connection is available only for read actions, use a client with write-tool access to build and publish pages.

**What success looks like.** Pageree is available in the conversation’s tools menu. Ask it to list your pages; an empty list is a valid result for a new account.

Official ChatGPT docs: https://developers.openai.com/plugins/deploy/connect-chatgpt

## Connect Cursor (editor, Editor agent)

**Before you connect.** Use an up-to-date Cursor editor with MCP enabled. Your organization may restrict custom servers.

1. **Add the configuration** Create or open ~/.cursor/mcp.json for all projects, or .cursor/mcp.json inside one project. Merge the pageree entry into any existing mcpServers object.

   ~/.cursor/mcp.json:

   ```json
   {
     "mcpServers": {
       "pageree": {
         "url": "https://mcp.pageree.com/"
       }
     }
   }
   ```

2. **Authenticate with Pageree** Open Cursor’s Customize / MCP settings (Tools & MCP in some versions). Find pageree and use its authentication control. Complete the browser sign-in and consent.

3. **Use the tools in Agent** Open an Agent conversation and make sure Pageree’s tools are enabled. If the server is missing, reload the editor after saving your configuration.

**What success looks like.** The MCP settings show pageree connected with tools available. Ask Agent to list your Pageree pages.

Official Cursor docs: https://cursor.com/docs/mcp

## Connect Codex (terminal, CLI & IDE extension)

**Before you connect.** Use a current Codex client. Local clients share ~/.codex/config.toml on the same host; a separate remote environment may need its own configuration.

1. **Register the remote server** Run this in your terminal. It adds Pageree to your Codex MCP configuration.

   Terminal:

   ```bash
   codex mcp add pageree --url https://mcp.pageree.com/
   ```

2. **Sign in to Pageree** Run the login command, then complete the sign-in and authorization in your browser.

   Terminal:

   ```bash
   codex mcp login pageree
   ```

3. **Check the connection** Run codex mcp list. Start a new Codex session and use /mcp to inspect active servers and available tools. The IDE extension uses the same configuration on this host.

   Terminal:

   ```bash
   codex mcp list
   ```

**Prefer to edit the config file?** Instead of the add command, insert this table into ~/.codex/config.toml. You can also use .codex/config.toml in a trusted project. Then run the login command above.

~/.codex/config.toml:

```toml
[mcp_servers.pageree]
url = "https://mcp.pageree.com/"
```

**What success looks like.** Pageree appears in /mcp with its tools. Use the connection-check prompt to confirm account access.

Official Codex docs: https://developers.openai.com/codex/mcp

## Connect Claude Code (terminal, Terminal agent)

**Before you connect.** Install and sign in to Claude Code first. The command below makes Pageree available across your projects.

1. **Add Pageree over HTTP** Run this in your terminal. Use --scope project instead of --scope user if you want the configuration saved in this project’s .mcp.json.

   Terminal:

   ```bash
   claude mcp add --transport http --scope user pageree https://mcp.pageree.com/
   ```

2. **Authenticate inside Claude Code** Start Claude Code, enter /mcp, select pageree, and choose the authentication option. Complete sign-in and approve access in your browser.

   Inside Claude Code:

   ```
   /mcp
   ```

3. **Check the server** The /mcp menu shows the server’s status and tools. You can also inspect connections from your terminal.

   Terminal:

   ```bash
   claude mcp list
   ```

**Prefer to edit the config file?** For a manual project configuration, merge this into .mcp.json and approve the project server when prompted. Keep the type field set to http, then authenticate using /mcp.

.mcp.json:

```json
{
  "mcpServers": {
    "pageree": {
      "type": "http",
      "url": "https://mcp.pageree.com/"
    }
  }
}
```

**What success looks like.** Pageree is connected in /mcp. Ask Claude Code to list your Pageree pages.

Official Claude Code docs: https://code.claude.com/docs/en/mcp

## Connect VS Code (editor, GitHub Copilot)

**Before you connect.** Use current VS Code with a chat agent that supports MCP tools. Your organization must allow MCP servers.

1. **Add an HTTP server** Open the Command Palette with Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows/Linux. Run MCP: Add Server, choose HTTP, paste this URL, and name the server pageree. Select your user profile or workspace as the target.

   MCP server URL:

   ```
   https://mcp.pageree.com/
   ```

2. **Start and authorize** Run MCP: List Servers, select pageree, and start it. Review the server trust prompt and complete the browser authentication when prompted.

3. **Enable the tools in chat** Open Chat, choose Agent, and use Configure Tools to enable Pageree’s tools for the conversation.

**Prefer to edit the config file?** For manual workspace setup, use .vscode/mcp.json. VS Code uses a servers object at the top level. Merge with existing servers, then start and authenticate as above.

.vscode/mcp.json:

```json
{
  "servers": {
    "pageree": {
      "type": "http",
      "url": "https://mcp.pageree.com/"
    }
  }
}
```

**What success looks like.** Pageree is running in MCP: List Servers, and its tools are visible in Configure Tools.

Official VS Code docs: https://code.visualstudio.com/docs/agent-customization/mcp-servers

## Connect Gemini CLI (terminal, Google’s terminal agent)

**Before you connect.** Install and sign in to Gemini CLI first. These steps are for Google’s terminal agent, not the Gemini web or mobile app. You also need a Pageree account.

1. **Install the Pageree extension** Run this in your terminal. Review and confirm the installation prompt; the extension connects to https://mcp.pageree.com/. No API key or local server is needed.

   Terminal:

   ```bash
   gemini extensions install https://github.com/Pageree/gemini-extension
   ```

2. **Restart and authenticate** Start a new Gemini CLI session with gemini, or restart your existing session. Run the command below inside Gemini, then sign in to Pageree in the browser and approve access.

   Inside Gemini CLI:

   ```
   /mcp auth pageree
   ```

3. **Check the connection** Run /mcp list inside Gemini to inspect the connection. If Pageree is missing, run /extensions list and check that the extension is enabled. An existing mcpServers.pageree entry in your Gemini settings takes precedence over the extension.

   Inside Gemini CLI:

   ```
   /mcp list
   ```

**Prefer to edit the config file?** Instead of installing the extension, merge this entry into ~/.gemini/settings.json for global access, or .gemini/settings.json inside a project. Keep unrelated servers. Use httpUrl for Streamable HTTP, then restart and authenticate as above.

~/.gemini/settings.json:

```json
{
  "mcpServers": {
    "pageree": {
      "httpUrl": "https://mcp.pageree.com/"
    }
  }
}
```

**What success looks like.** Pageree appears in /mcp list with tools available. Ask Gemini to call whoami and list_pages without creating, changing, or publishing anything. Confirm the account is correct; an empty page list is valid for a new account.

Official Gemini CLI docs: https://geminicli.com/docs/extensions/

## Connect Windsurf (editor, Cascade agent)

**Before you connect.** Use a version with remote HTTP and OAuth support. The vendor’s documentation may redirect to Devin Desktop following product changes.

1. **Open your MCP configuration** Open the MCP panel in Cascade and use its configuration control to open mcp_config.json. Windsurf uses ~/.codeium/windsurf/mcp_config.json; use the file opened by your editor if your version has moved it.

   mcp_config.json:

   ```json
   {
     "mcpServers": {
       "pageree": {
         "serverUrl": "https://mcp.pageree.com/"
       }
     }
   }
   ```

2. **Save and connect** Merge the pageree entry with existing mcpServers and save. Refresh the MCP panel if needed, then select the Pageree authentication control and complete sign-in in your browser.

3. **Enable Pageree in Cascade** Make sure the server and its tools are enabled. Start a new Cascade conversation and send the connection-check prompt below.

**What success looks like.** The MCP panel lists Pageree’s tools after authentication. If no OAuth option appears, update the editor or use another supported client.

Official Windsurf docs: https://docs.windsurf.com/windsurf/cascade/mcp

## Connect Cline (editor, Editor extension)

**Before you connect.** Use a Cline release with remote Streamable HTTP and OAuth support. If your build only accepts static authorization headers, use another listed client for Pageree.

1. **Open Remote Servers** In the Cline panel, select the MCP Servers icon in the top toolbar and open the Remote Servers tab.

2. **Add the endpoint** Enter pageree as the server name and paste this URL. Select Streamable HTTP as the transport and choose Add Server.

   MCP server URL:

   ```
   https://mcp.pageree.com/
   ```

3. **Authorize your account** Follow the OAuth sign-in prompt for Pageree, approve access in your browser, and return to Cline. Keep the server enabled and check that its tools load. If no browser authorization is offered, check your Cline version’s OAuth support.

**Prefer to edit the config file?** Open MCP Servers → Configure → Configure MCP Servers and merge this entry. Keep type set to streamableHttp; omitting it can select legacy SSE. This config still requires a client capable of completing OAuth.

Cline MCP settings:

```json
{
  "mcpServers": {
    "pageree": {
      "type": "streamableHttp",
      "url": "https://mcp.pageree.com/",
      "disabled": false,
      "autoApprove": []
    }
  }
}
```

**What success looks like.** Pageree’s tools load in the MCP panel after browser authentication. Run the connection check before starting page work.

Official Cline docs: https://docs.cline.bot/mcp/mcp-overview

## Connect OpenCode (terminal, Open-source agent)

**Before you connect.** Use a current OpenCode release. Remote servers support OAuth discovery and browser authorization.

1. **Configure the remote server** Add this to opencode.json in your project. Merge with your existing mcp object. Keep OAuth discovery enabled by leaving the oauth option unset.

   opencode.json:

   ```json
   {
     "mcp": {
       "pageree": {
         "type": "remote",
         "url": "https://mcp.pageree.com/",
         "enabled": true
       }
     }
   }
   ```

2. **Authenticate** Run the command below and complete the Pageree sign-in and consent in your browser.

   Terminal:

   ```bash
   opencode mcp auth pageree
   ```

3. **Verify server status** List your servers, then start a new OpenCode session to use the Pageree tools.

   Terminal:

   ```bash
   opencode mcp list
   ```

**What success looks like.** Pageree is authenticated in the server list. Ask OpenCode to list your Pageree pages.

Official OpenCode docs: https://opencode.ai/docs/mcp-servers/

## Using another client

Look for support for remote MCP over Streamable HTTP and browser-based OAuth, then add a remote server with these values and sign in.

- Server name: pageree
- Server URL: https://mcp.pageree.com/
- Transport: Streamable HTTP
- Authentication: OAuth with automatic client registration

A chatbot using a Claude, Gemini, or GPT model still needs its own MCP integration; model choice alone does not add tool support. If your client only supports local command-based servers or static API keys, use one of the guides above or write to support@pageree.com.

## Check the connection

Send this in a new conversation with Pageree enabled. It checks account access without changing anything.

```
Use Pageree to list my existing landing pages. If I have no pages yet, tell me the connection works. Do not create or publish anything.
```

The agent should call Pageree and return your pages, or an empty list for a new account. If it only explains how to connect, check that Pageree’s tools are enabled for the conversation.

## Your first page

Give your agent a brief. Pageree brings the page-building skills, publishing tools, forms, and analytics.

```
Use Pageree to build a landing page for my business. First ask me about my offer, audience, and the action I want visitors to take. Include a lead form and show me a private preview before publishing.
```

Already have a page? Ask: “Show me where visitors drop off on my page.” or “Compare the last two versions of my landing page.”

## Troubleshooting

### I can’t find the option to add a server

Update your agent, then check the requirements at the top of its guide. Custom connectors can depend on the client’s plan and workspace permissions. Ask your workspace admin to enable them, or choose another client above.

### The server returns 404 or an SSE error

Use https://mcp.pageree.com/ exactly. Pageree’s public MCP endpoint is at the root: do not append /mcp or /sse. Choose Streamable HTTP. In Gemini CLI use httpUrl, in VS Code use type: "http", and in Cline use type: "streamableHttp".

### Sign-in loops or the server says Unauthorized

Finish the browser sign-in and consent before returning to the agent. Confirm you signed in to the intended Pageree account. Clear the client’s stored authentication for Pageree and connect again if the session is stale. For a terminal agent, keep the process running while the browser completes the callback.

### Connected, but my agent can’t find Pageree’s tools

Enable Pageree for the current conversation, refresh the server’s tool list, and start a new chat. In an editor, use Agent mode and check the tool selector. Confirm the configuration file belongs to the project or user profile you are currently using.

### The agent can read pages but cannot publish

Check whether your client or workspace allows write tools. Read-only access cannot publish or change pages. Also check the account or plan message returned by Pageree in your console. A successful connection does not override a client restriction or a Pageree account limit.

### My configuration already contains other servers

Add the pageree entry inside the existing server object and keep your other entries. JSON needs commas between entries and cannot contain trailing commas. For Codex, add the [mcp_servers.pageree] table only once. Paths starting with ~/ refer to your home folder; on Windows, open the equivalent folder under your user profile.

Still stuck? Email support@pageree.com with your client name, version, and error message. Remove tokens and personal data from any logs you share.

## Disconnect

To stop using Pageree in an agent, disable or remove it in that client’s connector settings. For file-based clients, remove only the pageree entry and restart the client. Use the client’s logout or clear-authentication option to remove stored credentials. Disconnecting a client does not delete your pages or cancel your Pageree subscription; manage your account in the console at https://console.pageree.com/.
