About the RocketPages MCP

RocketPages provides an MCP server that lets AI assistants such as Claude, ChatGPT, Cursor, Windsurf, and other MCP-compatible clients build and manage websites through natural conversation. The same capabilities are available through a REST API, so any HTTP client, dashboard, or integration can call them directly with API key authentication.


With the MCP server connected, your AI assistant can create websites, manage pages and sections, publish blog posts, configure SEO, set up custom domains, and more, all without leaving the conversation. The REST API exposes identical functionality for programmatic access.


71 tools across 11 categories, from site creation to billing, available through both MCP and REST, so you can build, manage, and scale your websites however you prefer.

Category
Description
Sites & Pages
14 tools to create, update, delete, duplicate websites and pages. Manage headers, footers, redirects, and site status via MCP and REST API.
Templates
2 tools. Browse and clone from templates across 20 categories to create sites from existing designs.
Custom Domains
6 tools to add, validate, and manage custom domains. Set primary domains and monitor SSL certificates.
Publishing
3 tools. Publish entire sites or individual pages. Check real-time publish status and get live URLs via MCP or REST API.
Content Sections
19 tools. 7 section tools, 3 item tools, 3 FAQ tools, and 6 table tools to manage 24+ section types with multiple layout variations.
Images
4 tools. Upload images, manage your media library, and transform with crop, rotate, flip, and zoom.
Blog Management
5 tools. Create posts with rich HTML, featured images, and SEO metadata. Configure and manage blog content.
SEO
4 tools. Update meta titles, descriptions, social images, favicons. Inject custom HTML, CSS, and JavaScript.
Forms API
4 tools. View contact form submissions grouped by month. Manage contributors and team access permissions.
Billing & Subscriptions
7 tools. View plans, create Stripe checkout sessions, manage subscriptions, and access invoice history.
Theme Discovery
3 tools. Browse curated color palettes, font pairings, and button style presets to customize your design.

Setup & Configuration

Connect the RocketPages MCP server to your preferred AI client. Choose your tool below and follow the configuration steps.


Claude Code

Add to your project's .mcp.json file:

{
  "mcpServers": {
    "rocketpages": {
      "type": "http",
      "url": "https://api.rocketpages.io/mcp"
    }
  }
}

Or use the CLI:

claude mcp add --transport http rocketpages https://api.rocketpages.io/mcp


Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.rocketpages]
url = "https://api.rocketpages.io/mcp"

Or use the CLI:

codex mcp add rocketpages --url https://api.rocketpages.io/mcp


Cursor

Add to .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "rocketpages": {
      "url": "https://api.rocketpages.io/mcp"
    }
  }
}


Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "rocketpages": {
      "serverUrl": "https://api.rocketpages.io/mcp"
    }
  }
}


VS Code / GitHub Copilot

Add to .vscode/mcp.json in your project root (requires VS Code 1.101+):

{
  "servers": {
    "rocketpages": {
      "type": "http",
      "url": "https://api.rocketpages.io/mcp"
    }
  }
}


Claude Desktop

Open Settings → Connectors → Add custom connector and enter the MCP server URL: https://api.rocketpages.io/mcp

Or add to claude_desktop_config.json:

{
  "mcpServers": {
    "rocketpages": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.rocketpages.io/mcp"]
    }
  }
}


ChatGPT

Open Settings → Apps & Connectors → Create and enter the MCP server URL: https://api.rocketpages.io/mcp. Save the connector and attach it in any new chat. Requires a paid ChatGPT plan.


First-Time Connection

When your client connects for the first time:


  • A browser window opens for authentication.
  • Sign in with your RocketPages account.
  • Approve the requested permissions.
  • Your client receives tokens automatically and is ready to use.

Quickstart — Build Your First Site

Step 1 — Connect Your MCP Client

Add the RocketPages MCP server to your client configuration (see Setup & Configuration above).

When your client connects for the first time:


  • A browser window opens for authentication.
  • Sign in with your RocketPages account.
  • Approve the requested permissions.


Step 2 — List Your Websites

Ask your AI client:


List all my websites

The MCP server calls list_websites and returns website IDs, names, subdomains, and publish status.


Or call the REST API directly:

curl -H "Authorization: Bearer rp_key_<your_api_key>" https://api.rocketpages.io/api/configs/users-site-configs

If you don't have any websites yet, continue to Step 3.


Step 3 — Create a Website

Ask your AI client:


Create a new website called "My Portfolio"

The MCP server calls create_website, guides you through a questionnaire, and returns your site_id, site name, subdomain, and editor URL.

Your website is created with a default homepage.


Step 4 — Browse Templates (Optional)

Ask your AI client:


Show me available templates in the Portfolio category

The MCP server calls list_templates and returns available templates across multiple categories.

You can create a website from a template instead of starting from scratch.


Step 5 — Add Content Sections


Ask your AI client:

Add a welcome section with the title "Welcome to My Portfolio" and a services section with 3 cards for Web Design, Development, and Branding

The MCP server calls add_section for each requested section.

To explore available layouts first, ask:


Show me available layouts for welcome sections

The MCP server calls list_layouts and returns supported layout variations.


Step 6 — Customize Styling

Ask your AI client:


Show me available color palettes and apply one with blue tones. Also show me font pairings.

The MCP server calls list_color_palettes and list_font_pairings.

Apply any palette or font combination using update_website.


Or via REST API:

GET /api/configs/color-palettes
GET /api/configs/font-pairings


Step 7 — Publish Your Site

Ask your AI client:


Publish my website and show me the live URL

The MCP server calls publish_website and returns your live URL.

Your website is now live.


Step 8 — Add a Custom Domain (Optional)

Ask your AI client:


Add the custom domain example.com to my site

The MCP server calls add_custom_domain and provides the DNS records required for configuration.

After updating DNS records, verify the setup:


Validate my custom domain

The MCP server calls validate_custom_domain.

To monitor SSL certificate provisioning:


Check SSL status for my custom domain

The MCP server calls check_ssl_status.


What's Next?

You can now:


  • Explore the full tools reference for all 71 MCP tools.
  • Use the REST API to build custom integrations and dashboards.
  • Create websites from templates.
  • Customize layouts, styling, and content.
  • Connect custom domains.
  • Build automations using the REST API with your API key.

Protocol & Transport

MCP Protocol (JSON-RPC)


Base URL: https://api.rocketpages.io/mcp


All MCP tool calls are sent to this single endpoint using JSON-RPC 2.0 over HTTP with Server-Sent Events (SSE) for streaming. Authentication is handled automatically by your MCP client.


REST API (Direct HTTP)


Every MCP tool is also accessible as a standard REST API endpoint. Use a permanent API key for authentication. No MCP protocol or JSON-RPC required.


Base URL: https://api.rocketpages.io/api


Headers:

Content-Type: application/json
Authorization: Bearer rp_key_<your_api_key>


REST API Example: List Websites


GET /api/configs/users-site-configs

Response:
{
  "data": [
    {
      "siteId": "abc123",
      "siteName": "My Business",
      "isPublished": true,
      "subDomain": "my-business"
    }
  ]
}


REST API Example: Get Site Config


GET /api/configs/site-config?siteId=abc123

Response:
{
  "data": {
    "siteId": "abc123",
    "siteName": "My Business",
    "isPublished": true,
    "subDomain": "my-business",
    "header": { ... },
    "footer": [ ... ],
    "palette": { ... }
  }
}


REST API Example: Update Site


POST /api/configs/append-site-config
Content-Type: application/json

{
  "siteId": "abc123",
  "siteName": "Updated Name"
}


MCP vs REST API


  • MCP tools — designed for AI assistants. One tool call can orchestrate multiple API calls, handle validation, generate content, and return formatted results.
  • REST API — designed for developers and integrations. Direct HTTP access to individual operations. You handle orchestration.


Both access the same underlying service layer.


MCP Sample Request: list_websites


Request:


{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "list_websites",
    "arguments": {}
  }
}

Response:


{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": {
          "websites": [
            {
              "site_id": "2e2b85c5-...",
              "site_name": "My Site",
              "sub_domain": "mysite",
              "is_published": true,
              "site_url": "mysite.rocketpagesweb.com"
            }
          ]
        }
      }
    ]
  }
}


MCP Sample Request: create_website


Request:


{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "create_website",
    "arguments": {
      "site_name": "My Portfolio",
      "sub_domain": "myportfolio"
    }
  }
}


Response:


{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": {
          "success": true,
          "site_id": "a1b2c3d4-...",
          "site_name": "My Portfolio",
          "sub_domain": "myportfolio",
          "editor_url": "https://editor.rocketpages.io/a1b2c3d4-..."
        }
      }
    ]
  }
}


MCP Sample Request: add_section


Request:


{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "add_section",
    "arguments": {
      "site_id": "a1b2c3d4-...",
      "page_id": "f7g8h9i0-...",
      "section_type": "welcome",
      "layout": "welcome_v1",
      "title": "Hello World",
      "description": "Welcome to my site"
    }
  }
}


Response:


{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": {
          "success": true,
          "section_index": 0,
          "section_type": "welcome",
          "layout": "welcome_v1"
        }
      }
    ]
  }
}

Error Handling

Standard HTTP status codes and application-specific error codes returned by both MCP tool calls and REST API endpoints.

HTTP Status Codes

Data table

Status Code
Name
Description
200
OK
Request succeeded
400
Bad Request
Missing or invalid parameters
401
Unauthorized
Invalid or missing authentication
403
Forbidden
No permission on this resource
404
Not Found
Resource does not exist
409
Conflict
Duplicate resource (e.g., URL slug already taken)
429
Too Many Requests
Rate limit exceeded
500
Internal Server Error
Server error — retry with exponential backoff

Error Codes

Data table

Error Code
Description
INVALID_PARAMS
Required parameter is missing or has an invalid type
INVALID_ID
site_id, page_id, or section_id is not a valid UUID
RESOURCE_NOT_FOUND
Website, page, section, or item does not exist
DUPLICATE_SLUG
Page URL slug already exists on the website
RESERVED_SLUG
The slug /blog is reserved for the blog system
INVALID_LAYOUT
Layout ID does not exist for the specified section type
PERMISSION_DENIED
You do not own the website and are not a contributor
TOKEN_EXPIRED
API key is invalid or has been revoked
RATE_LIMITED
Too many requests were sent — wait and retry
BRANDING_PROTECTED
RocketPages branding cannot be modified via custom code
INJECTION_BLOCKED
Custom code contains disallowed or unsafe patterns
SVG_SANITIZED
Uploaded SVG contained scripts or unsafe content that was removed

Sample Error Responses

400 — INVALID_PARAMS

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": {
      "error_code": "INVALID_PARAMS",
      "details": "site_id is required"
    }
  }
}

404 — RESOURCE_NOT_FOUND

{
  "jsonrpc": "2.0",
  "id": 2,
  "error": {
    "code": -32602,
    "message": "Resource not found",
    "data": {
      "error_code": "RESOURCE_NOT_FOUND",
      "details": "No website found with id 'abc-123'"
    }
  }
}

409 — DUPLICATE_SLUG

{
  "jsonrpc": "2.0",
  "id": 3,
  "error": {
    "code": -32602,
    "message": "Duplicate slug",
    "data": {
      "error_code": "DUPLICATE_SLUG",
      "details": "A page with slug '/about' already exists"
    }
  }
}

429 — RATE_LIMITED

{
  "jsonrpc": "2.0",
  "id": 4,
  "error": {
    "code": -32000,
    "message": "Rate limited",
    "data": {
      "error_code": "RATE_LIMITED",
      "details": "Too many requests. Please wait before retrying.",
      "retry_after_seconds": 60
    }
  }
}

Rate Limiting & Best Practices

Rate Limits


The RocketPages MCP server enforces per-user rate limits to ensure fair usage and maintain server stability.


If a rate limit is exceeded, the server responds with:


  • HTTP 429 Too Many Requests
  • RATE_LIMITED error responses
Creating multiple API keys for the same account does not increase your rate limit.

Rate limits are designed for normal interactive MCP client usage.


Retry Strategy

When requests fail due to rate limiting or temporary server issues, implement a retry strategy.


Exponential Backoff

Retry failed requests using increasing delays:


  • Attempt 1 → 1 second
  • Attempt 2 → 2 seconds
  • Attempt 3 → 4 seconds
  • Attempt 4 → 8 seconds

Recommended maximum:


  • 3–5 retry attempts


Jitter


Add a random delay of 0–500ms to each retry attempt.

Benefits:


  • Prevents thundering herd issues
  • Reduces simultaneous retry spikes
  • Improves overall system stability


Automatic Retry Handling

Most MCP client SDKs implement retry logic automatically.


Idempotency

Understanding which operations can be safely retried helps prevent unintended side effects.


Read Operations

The following operations are always safe to retry:

  • list_websites
  • list_pages
  • get_page_sections


These operations do not modify data.


Update Operations

The following operations are idempotent:


  • update_section
  • update_page


Submitting the same update multiple times produces the same result.


Create Operations

Create operations are not always idempotent.

Recommendations:


  • Check for existing resources before creating new ones.
  • Avoid duplicate requests.
  • Duplicate URL slugs will fail with a DUPLICATE_SLUG error.


Delete Operations

Delete operations are idempotent.

If a resource has already been deleted:


  • The server returns 404 Not Found.
  • No additional side effects occur.


Best Practices


Always List Before Mutating

Before creating, updating, or deleting resources:


  • Call listing tools first.
  • Retrieve valid IDs.
  • Verify the current state.


Use list_layouts Before Adding Sections


Never assume a layout ID exists.

Always:


  1. Call list_layouts.
  2. Select a valid layout.
  3. Add the section using the returned layout ID.


Check Publish Status


Content changes are not visible publicly until you publish.

Use:


  • publish_website
  • publish_page

to make changes live.


Cache Listing Results


During a session:


  • Site IDs remain stable.
  • Page IDs remain stable.

Reuse previously retrieved IDs instead of repeatedly calling listing endpoints.


Handle Partial Failures


For multi-step workflows:


  1. Track IDs returned from successful operations.
  2. If a later step fails, resume from the failed step.
  3. Avoid restarting the entire workflow.


This reduces unnecessary API calls and helps prevent duplicate resources.

Troubleshooting

Common issues and solutions when connecting to the RocketPages MCP server

Browser window doesn't open or gets stuck

Ensure your default browser is set and not blocked by a firewall or popup blocker. The MCP server opens a browser window for authentication when you connect for the first time. If you're using a headless environment (e.g., SSH or Docker), authentication may not work — try running from a local machine with a GUI. You can also try clearing your browser cookies for the RocketPages domain and retrying.

Tools not appearing in my AI client

Verify that your MCP configuration is correct and the server URL is exactly https://api.rocketpages.io/mcp. Restart your AI client after saving the configuration. For clients using npx mcp-remote, make sure Node.js (v18+) and npm are installed and accessible from your terminal. Check your client's MCP logs for connection errors — most clients have a dedicated MCP or extension log panel.

401 Unauthorized errors

For REST API users, verify your API key is correct and has not been revoked. Check that the header format is exactly Authorization: Bearer rp_key_<your_api_key>. For MCP clients, try disconnecting and reconnecting the MCP server in your client. For clients using npx mcp-remote, delete the cached credentials in your system's temp directory and restart the proxy to trigger a fresh login.

npx mcp-remote proxy fails to start

Make sure you have Node.js version 18 or later installed. Run node --version to check. If the command hangs, check whether another process is using the same port. You can also try running npx -y mcp-remote https://api.rocketpages.io/mcp directly in a terminal to see detailed error output. On Windows, ensure your terminal has permission to execute npm global packages.

429 Too Many Requests or rate limiting errors

The RocketPages MCP server enforces rate limits to protect the service. If you hit a 429 error, wait a few seconds before retrying. Avoid making rapid sequential tool calls — batch your changes where possible. If you consistently hit rate limits during normal use, contact support at support@rocketpages.io.

Tool calls fail silently or return unexpected errors

Make sure you're passing all required parameters. Common mistakes include missing the site_id when it's required, or using an incorrect page_id. Call list_websites first to get your site ID, then list_pages to get valid page IDs. Check your AI client's MCP debug logs for the full error response — it often contains a descriptive message explaining what went wrong.

Changes not appearing on my live site

Edits made through MCP tools update the draft version of your site. You need to publish for changes to go live. Use the publish_website or publish_page tool to push your changes to production. If you've already published and still don't see updates, try clearing your browser cache or checking in an incognito window — CDN caching may delay updates by a few minutes.

Authentication and Security

API Key Authentication


All REST API requests are authenticated using permanent API keys. Keys do not expire and require no token refresh logic.


  • Prefix: rp_key_
  • Expiry: None — keys are valid until explicitly revoked
  • Create: In your dashboard at Site Settings → API & MCP Access
  • Usage: Authorization: Bearer rp_key_<your_api_key>
  • Scope: Full access to all REST API endpoints for sites you own or contribute to
  • Revocation: Revoke anytime from the dashboard. Keys are also revoked on password change.
  • Limit: Up to 5 active keys per account


# Example: List your websites
curl -H "Authorization: Bearer rp_key_<your_api_key>" \
  "https://api.rocketpages.io/api/configs/users-site-configs"


MCP Client Authentication


MCP clients (Claude Code, Cursor, ChatGPT, etc.) authenticate automatically. When you connect for the first time, a browser window opens — sign in with your RocketPages account and approve permissions. Your client handles everything from there.


Security Measures


  • API Key Storage: Keys are stored as SHA-256 hashes. The plaintext key is shown only once at creation time.
  • Code Injection Scanning: All custom HTML, CSS, and JavaScript submitted through update_custom_code is scanned for malicious patterns before being stored.
  • SVG Sanitization: Uploaded SVG files are sanitized to prevent embedded scripts and XSS attacks.
  • Branding Protection: RocketPages branding elements are protected from removal or modification through custom code injection.
  • CSRF Protection: State parameter required in the MCP authorization flow to prevent cross-site request forgery.
  • Secret Verification: Client secrets are verified using constant-time comparison to prevent timing attacks.
  • Rate Limiting: All API endpoints are rate-limited per user to prevent abuse, applied consistently across both MCP and REST API access.